Patent Description:
To organize multiprocessor systems, three main computing device architectures for effective parallel computations (or computation parallelization) are known, these being a shared memory architecture, a separate memory architecture, and a non-uniform memory access architecture.

In the shared memory (or Uniform Memory Access, UMA) architecture all processors are connected to a physically shared memory bank. Such architecture is advantageous because it is simple to implement, and each processor can have equal access to the entire memory address space. The disadvantage of the computing system based on the shared memory architecture is in the so-called "Memory Wall" problem: the more processors using a single common bus connecting processors and memory are used, the more intense the conflict between processors for memory access is. Consequently, at some point every new added processor will reduce the overall computing system efficiency.

The separate memory architecture is a cluster of multiple nodes. Each unit comprises several processors and an own memory bank. Processors of one node can access only their own memory bank. The nodes share data by means of a network messaging system connecting these nodes. Examples can include a group (cluster) of workstations (nodes) connected via LAN. The drawback of this architecture is in extreme programming complexity related to the multiplicity of general data processing procedures launched on different nodes, and the synchronization of such procedures. However, this separate memory architecture is used to build the most powerful supercomputers.

The non-uniform memory access, or NUMA, architecture and variants thereof are a combination of two previously described architectures. Here a cluster is divided into nodes, and each node comprises its own memory bank but these memory banks, being distributed physically, are virtually combined to form a single address space. For instance, an address used by a memory bank of a first node lies within <NUM> to <NUM>, an address of a second node lies within <NUM> to <NUM>, etc. Memory access time depends on the address: the processor access time to the memory bank in the "own" node is minimal, but when the processor accesses a memory bank of a "foreign" node, the access time is increased due to transmission of data between the nodes. The longer the distance between the nodes is, the longer it takes for the processor to access the "foreign" node memory bank. The problem of the relatively high access time is partially solved by use of network caches (or cache coherent systems with a shared and separate memory, ccNUMA), although said problem is still of concern for high-performance systems.

From <NPL> the computing architecture is known operating exclusively in the data flow mode, or by readiness of data, a so-called the "dataflow architecture", and comprising multiple computing devices. The architecture has an instructions memory that is common to all computing devices and provides for parallelization of the computation. For this purpose, a special programming language Id and a respective compiler intended for this specific computing architecture (also known as "a MIT architecture") are used, which is one of the main drawbacks of this approach to the parallelization. Data processed by instructions are located in the associative memory. Since this type of memory is expensive and energy-consumptive, the MIT architecture uses the associative memory of small capacity. Consequently, the amount of stored processed data is low. The parallelization is carried out at a level of instructions performed in a data flow (i.e. when data are ready), and a possibility to execute a program in the mode of instruction flow is not provided at all by the MIT architecture.

In <CIT>, IPC G06F15/<NUM>, G06F9/<NUM>) disclosed is the data flow-based information processing system comprising one or more associative memory modules, the first switch, the second switch, the second memory adapted to temporarily store pairs of data and tokens, the second memory adapter and the parallelism-regulating processor. Each associative memory module comprises plurality of executive units to process pairs of data from the associative memory module. Data is transferred between the associative memory modules and the executive units in the form of tokens comprising a data field and a key field. The associative memory modules store the tokens, search for the tokens within the stored tokens having the key that matches the key of the incoming token; in case the search fails, keep the incoming token in the memory; in case of the successful search, form a data pair based on the token entering the associative memory and the token found in the associative memory; direct the formed data pair to any of the executive units. The executive unit is used to execute instructions stored in the instructions memory accessible by the executive units at addresses specified in the data pair; to form the token comprising the data field and the key field, where the data field comprises a result of the instruction, and the key field is filled with an information about the instruction for which said result appears to be a parameter; to calculate a hash function that determines an ID of the associative memory module; to direct the formed token to any ID of the associative memory module according to the calculated hash function. The first switch directs the tokens from any of the executive units to any of the associative memory modules; receives tokens entering from other similar information processing systems and comprising the ID of the system for which they are intended; detects the tokens intended for the system which the first switch belongs to; directs the detected tokens to the associative memory of this system. The second switch directs data pairs from any of the associative memory modules to any of the executive units.

To control the processing and save occupied volume of the associative memory, the system of <CIT> comprises the second memory adapted to temporarily store the pairs of data and tokens. The second memory receives the tokens to be stored from the executive units and the associative memory; receives the pairs of data to be stored from the associative memory; outputs the stored tokens and pairs of data to the associative memory. The second memory is controlled by the second memory adapter that determines a location in the second memory for storing the tokens and the pairs, distinguishes the tokens as "tokens unloaded by a cover token", "unloaded written tokens" and determines a location to store in the second memory the tokens of different types. In addition to gathering information about loading efficiency of the associative memory and the executive units, the parallelism-regulating processor directs the tokens from the associative memory to the second memory and backward, directs the control tokens to the associative memory and directs the pairs of data from the second memory to the executive units.

<CIT> discloses also a system evolved from the system disclosed in <CIT>. The system is arranged for enabling a software procedure executed on any executive unit to cause the latter to call another software procedure on another executive unit by sending a data stream to it containing a procedure identifier of the other procedure and the parameters for its execution. An executive unit arbiter of the system is able to identify a free executive unit among the executive units. So it is possible for an executive unit to call a procedure on any other executive unit by cooperating with the latter. The system allows to run control-flow based programs, but also data-flow based programs with help on an associative memory which may be implemented in hardware or software.

Said data flow-based information processing system of <CIT> appears to be the closest analogue of the present invention. This system provides for the increase of operational reliability, in particular reduces the risk of a deadlock event (or deadlocks) upon overflowing of at least one associative memory module in the course of the computational process, as well as provides means for controlling the course of the computational process at an operating system and a user end.

The drawback of the closest analogue is that the deadlocks cannot be prevented completely since this system can only control a program in a data flow mode. Consequently, there is a need to use a further parallelism-regulating processor responsible for loading of the associative memory. In addition, the closest analogue requires the use of a larger associative memory that is power consuming and expensive. Another drawback is the overall complexity of the computing system which requires to form and transmit additional tokens to reduce the risk of deadlocks.

The present invention is aimed at addressing the drawbacks of the known systems, including the drawbacks of the closest analogue.

The object of the present invention is to provide a computing device and a computing system based on such computing device, which automatically parallelize computations between computing devices during execution of a program in the computing system, along with the use of two levels of parallelism, namely a so-called "coarse-grain" parallelization of computations and a "fine-grain" parallelization of computations.

The coarse-grain parallelization of computations is executed at the level of procedures included into a program. At this level, the program can be represented as a logic graph having nodes with the procedures allocated therein, while graph arcs connecting the nodes indicate a direction of data transmission between the procedures. As soon as all input parameters for a given procedure are ready, any vacant (i.e. not busy at this moment) processor of the computing system can automatically execute the procedure. Node exits are made to send messages of tokens having parameters to another node, i.e. to another procedure, according to the computational graph while the procedure is executed. The order of the procedure calls is of no importance; all that matters is readiness of the parameters at the inputs of the procedure to be executed. This allows to achieve the automatic parallelism at the procedure level.

The fine-grain parallelization of computations is executed at the level of instructions included into a device, hereinafter also called as a specific co-processor or just a co-processor (CP). The architecture and mode of operation of this CP for parallel processing of data represented as matrices will be described below. It should be noted that, in general, the CP is not a vector processor, because each core of the CP (or CP core) can currently execute various instructions, including conditional statements (conditional operations).

In the CP, computations are made in the data-flow mode, and the data to be processed are stored in a RAM-type memory which is comprised in the CP core.

Basically the present invention provides for a hybrid computing system functioning both in the modes of data flow and instruction (or command) flow.

The technical effect achieved by the present invention is prevention of deadlocks, simplification of the computing device and computing system architecture, provision of a high parallelism with simultaneous reduction of requirement to a volume of associative memory used.

A co-processor (CP) of the present invention comprises a matching device; one or more executive units (EU) to execute elementary or arithmetic operations with integer and real numbers; a RAM-type memory (or a RAM-type memory controller) to store data and intermediate results of computations; an address computing device to convert an address given a predetermined format, e.g. in the form of [Row,Col], to an address in the RAM-type memory; a token generator to form resultant tokens for each of outputs; and a network controller to combine a plurality of computing devices into a network.

The operating principle of the computing system according to the present invention is in parallel operation of a plurality of procedures which control the course of computations in the CP in accordance with an operating algorithm of the procedure and provide a plurality of CPs with data in the form of tokens in accordance with a "send and forget" model. In other words, said plurality of procedures directs the data towards the computing devices and does not expect to receive any response from these computing devices, for instance, a computation result, to continue the execution.

Accordingly, in the computing system according to the present invention, it is suggested to control a program by a conventional von Neumann architecture via the procedures and to control computations in the data flow mode via the instructions, which creates a fundamental difference between the present invention and all already known approaches, including the closest analogue.

For the sake of better understanding the present invention, the following terms will be used.

This is a logical functional element for elementary transformations (conversions) of input data into output data. The node has one or two inputs and one or two outputs. Input and output data in the node are in the form of a specific structure of data known as tokens (see below). A node table determines an arithmetic operation in the node, identifies input operands, rules of transformation of input data into output data, transmission directions and terms for returning a result per each output. The node has a unique ID which identifies the node in the node table, said ID being a row (or address) in the node table.

This is a small computing graph with peaks comprising computing nodes and arcs (edges) being connections for data transmission between outputs of current nodes and inputs of next nodes. Computations in a data flow mode are advantageous because of the automatic parallelism of computations at the level of instructions (instruction level) in the course of the program. On the other hand, the computing graph representing an application is much harder to understand by a software engineer than a typical sequential algorithm, especially when such the graph is large. For this reason, the disclosure of the present invention incorporates a concept of a scheme, according to which a scheme is a logically-complete small computing graph having inputs and outputs. Schemes can be either permanently stored in a node table (see below), or dynamically loaded into the node table when called. The scheme can be created without any specific compiler because the scheme can be programmed by simply filling fields of the node table.

The scheme has several inputs and outputs. The scheme starts computations when data is provided to the inputs thereof. The computations are carried out in the data flow mode. Data is transmitted between the nodes by means of the tokens. The main difference of the computing device and the computing system of the present invention from the known devices and systems operating in the data flow mode is in that, according to the present invention, the associative memory stores only intermediate values of the computation and/or operands which currently require (wait for) a second operand. In contrast to the prior art, according to the present invention, the processed data and results are stored, preferably, not in the associative memory, but in the RAM-type memory (Random Access Memory). In particular, data addressing in the RAM-type memory is executed by means of a DataID field of an input token (see below).

Computing matrix. To determine algorithms, schemes can use own inputs and outputs to be integrated horizontally and vertically into a computing matrix to parallelize the computations by rows and columns. Accordingly, the DataID field of a token can be divided into two identical parts, namely a Row and a Col (Column). A second operand of an instruction can be addressed in the format of (Row,Col), and the address is detected in the RAM-type memory by means of hardware means of the computing device, for instance, by means of a module for computing linear memory addresses, while executing the instructions.

The computing matrix provides for computations in the data flow mode. Each individual element of the computing matrix is processed in parallel with the other elements by its own scheme using arithmetic and conditional statements (operations). After the scheme in a given matrix coordinate has executed the computation, the scheme transfers the computation results to the adjacent schemes. The computation result can be also transmitted to the adjacent schemes based on any condition. When the matrix activity is stopped or a special message on a current transaction is received from the matrix, it means that a computing process is finished. Also, when the computations are over, the computing device memory, in particular, the RAM-type memory, will contain the matrix operation results. These data will be either used in further computations or returned to a host processor (a master or main processor). The computing matrices are preferably integrated into a typical sequential algorithm where parallel computations, for instance, same-type computations using vector and matrix elements, are required. In this way, a host processor program will be some kind of a layered configuration consisting of linear code and schemes. In other words, the present invention allows distribution of computations both in space within the executive units of the computing device, and in time by setting with the host processor a sequence of computations in the computing device.

Instruction. Each row in a node table (see below) is given in the form of instructions. A row address in the node table is a node identifier (NodeID). The instruction indicates what to do with input operands and how to form results at each of the node outputs.

For example, without limiting the present invention, an instruction may comprise the following fields:.

For each of OUT1 and OUT2 outputs of a node the following fields can be defined:.

IR, OOR, DirRow,DirCol - together with the DataId field serve to arrange cycles.

Transaction. This is a plurality of computing operations in nodes combined by a common transaction identifier. The transaction is started by directing a token (tokens) to an input (inputs) of a scheme where all computations begin. The transaction is finished when the generation of tokens with this token identifier is stopped. Transaction execution results are stored in the RAM-type memory of a computing device. The transaction is executed by a CP.

This is a plurality of simultaneously running transactions. The fragment is finished when token generation and a computing process in a computing matrix are stopped. The fragment can consist of one transaction. The fragment is executed by a CP.

Macro-node. This is a typical procedure having parameters which are node inputs, but unlike a typical procedure, as soon as all inputs receive data, a vacant processor automatically executes a macro-node. The macro-node is implemented using a typical processor with any known architecture. It executes a sequence of instructions in accordance with an application algorithm and sets a sequence of the fragment (transactions) execution in a CP. The macro-node can have any number of inputs and outputs. Macro-node outputs are implemented by sending messages (tokens) to inputs of other macro-nodes.

This is a computational graph with nodes that are macro-nodes and arcs (edges) that are directions of the data transmission from an output of one macro-node to an input of another macro-node.

Directing a procedure by the associative memory module means sending a package consisting of a procedure address and a list of parameter values (parameters) to any vacant EU. A service based on this EU decodes the received package, arranges the parameter values based on the parameter transmission agreement, removes an EU index from a list of vacant EUs and executes the procedure. Upon completion of the procedure, this EU places this EU index in the list of vacant EUs. In the present disclosure, the term "Service" means an application run at a CP core which listens to messages received via a network, decodes them (picks out of the message a procedure address and parameters), sends to an arbiter a message about that the CP core is currently busy, starts a procedure, waits for a return from the procedure and, upon completion of the procedure, sends to the arbiter a message about that the core is now vacant (free). The agreement is a standard of the parameter arrangement in registers or a stack (for instance, in such languages as "C" or "Pascal").

The procedure is not a graph. A procedure code is a common "control flow" code executed only at one EU, and this code initiates computations in a CP which performs computations in the data flow mode using a plurality of EUs thereof.

The procedure in this computation model is a graph node, where node inputs are parameters and node outputs are the sendings of tokens with parameter values of other procedures. By this, the coarse-grain parallelization mentioned above is implemented.

The parallelization at the level of elementary or arithmetic operations in the data flow mode is used only in a CP, which means the fine-grain parallelization.

The elementary or arithmetic operations will be described below, and for the sake of clarity such operations will be hereinafter also referred to as "operations" or "operators".

In addition to the mentioned above, instructions can serve to control the course of a transaction.

A computing device includes two or more EUs which execute operations included in the transaction. One skilled in the art will understand that the number of operations in a transaction and, accordingly, the number of graph nodes can drastically vary (for instance, be lower) from the number of available or existing EUs in the computing device. It should be understood that in this case, the maximum number of operations of this transaction that can be executed in parallel is the number that matches the number of available or existing EUs. Other operations of this transaction will be executed at the vacated EUs. If the number of EUs is higher than the number of operations of this transaction, it is obvious that not all of the EUs will execute the transaction in this computing device.

In this way, in terms of a functionality, the term "node" logically matches the term "executive unit" meaning a physical device, although, for instance, the number of nodes can vary: the number of nodes is defined by the complexity of a computing graph (in particular, by the number of operations to be executed in a specific transaction) and a program code in general, while the number of EUs in a specific computing device remains unchanged.

As mentioned above, each node has one or two inputs and one or two outputs, wherein according to the computing graph, the node outputs are connected, if necessary, to inputs of further nodes. The node comprises an operator to be executed immediately as soon as the node inputs receive all the required data, i.e. the node operates on the principle of the data readiness (in the data flow mode). The advantage of this principle is that, unlike the von Neumann architecture, the sequence of operator executions has no significance; all that matters is the presence of all necessary data at the inputs of the node where the operation is executed. This allows to automatically parallelize computations at the instruction level in the course of the program.

The "automatic parallelism of computations" or the "automatic computation parallelization" means a computation parallelization including the distribution of computations between computing devices (in particular, executive units comprised in coprocessors) without involving a software engineer, i.e. when computations do not require specific codes to be written. Indeed, if all data for a specific operator is ready, any vacant EU can be selected, and this very EU can be provided with an operator, all data required for computations by this specific operator and an address and an input ID of a further node in a computation flow (i.e. in a procedure code) whereto the result of the execution of said specific operator on said data (operands) in said vacant EU will be sent.

Node table. According to the present invention, a description of each node and connections between nodes are stored in a node table included in a computing device. In general, the node table comprises the following information about each node:.

The node table can also comprise fields for each of the node outputs responsible for the transmission direction of a resultant token to the adjacent schemes. In general, for instance, the scheme can have several inputs and outputs and, accordingly, can transmit data between any computing matrix cells, not only the adjacent ones.

The purpose of fields of the node table and the presence of other fields will be described below in detail.

Preferably, the node table is located in a conventional memory, for instance, a RAM-type memory.

Data (operands) is transferred in a computing device, e.g. between EUs, and between computing devices within a computing system by means of tokens. For example, a token can comprise the following fields:.

In general, the token comprises the following information:.

The purpose of the token fields and the presence of other fields will be described below in detail.

If the information about the nodes is stored in the node table, the matching device is aimed at forming two operands (operand pairs) matching each other, to execute operations with said operands in the EU.

If the node for the operator therein has only one input (i.e., the operator is executed with one operand), a corresponding token, once in the matching device, is immediately forwarded directly to the EU selected to execute this operator.

Tokens waiting for their paired tokens to carry out operators executed on them (i.e., such operators which are executed on two operands) are preferably located in the associative memory which is a component of the matching device.

The token fields of "Identifier Node", "Transaction Identifier", and "Data Identifier" form the token key based on which the matching device searches for a paired token for a newly received token. Before writing said newly received token into the associative memory, the matching device checks whether the associative memory already comprises a token with the same key as of the newly received token, i.e. a paired token.

If the paired token is not found in the associative memory, the newly received token is written into the associative memory. If the paired token already exists in the associative memory, the matching device forms a data structure consisted of the newly received token and the data field of the paired token stored in the associative memory. The node identifier field of this structure stores a row address in the node table comprising all necessary information about further operation and rules for formation an output token. When the matching device forms a pair of operands and an operator (and the additional information including an address of next EUs to direct a result and a data identifier thereto), the computing device selects a free EU, and the formed data structure is transmitted to this selected EU to execute the operator, and the paired token stored in the associative memory is deleted therefrom, unless otherwise stated.

In accordance with the present invention, provided is the following alternative embodiment of allocation of the data waiting for their paired tokens to execute operators on them.

It is known that the hardware associative memory is energy consuming and difficult to make, because, in addition to a key and data, each cell of such memory comprises a comparator for simultaneous parallel key-based search for data in all memory cells. Therefore, it is extremely inefficient and expensive to store large volumes of data, e.g. data arrays, in the associative memory. On the other hand, the typical RAM-type memory can store at least a portion of this data if it is known that this data is available and correct for further computations (for instance, it remains unchanged for some time). In this' case, the matching device can comprise both the associative memory and the RAM-type memory. In this way, the required volume of the associative memory can be reduced significantly. Thus, the associative memory will store only a small number of unpaired tokens required for current computations with the automatic parallelism, while the rest of the data being processed will be stored in the RAM-type memory. It should be noted that the RAM-type memory stores only data and does not store tokens.

In order to achieve said alternative allocation of the second operand, the node table comprises fields indicating which one of the operands is left and which one is right. Values in MEMO and MEMORC fields indicate that the second operand is in the RAM-type memory of the matching device. In fact, this node will be of "mono input" type (i.e. has a single input), because the second operand will be selected not from the associative memory, rather from the RAM-type memory of the matching device based on the address indicated in the field of "Data Identifier" (DataID field) of the token. Accordingly, the operation result can be stored in the associative memory or in the RAM-type memory of the matching device. Unlike the embodiment where data is stored in the associative memory, when data is stored in the RAM-type memory of the matching device, a paired token is unsearchable.

When the operator is executed, the executive unit forms result tokens and sends them to the matching device of the core prescribed by the value in the field "Data Identifier".

Operation, operator. In general, an operation, or an operator, can be any arithmetic or elementary operation executed on one or two operands. In particular, the operator can be an arithmetic operator of addition, subtraction, multiplication, division, squaring, square rooting, etc. The operator can be an integer to real, real to integer, etc. conversion operator. Also, the operator can be an operator of comparison between integers and/or real numbers, such as "equal to", "not equal to", "greater than", "less than", "greater than or equal to", "less than or equal to". The operator can be a duplication function (or a splitter function), when, for instance, the same operand has to be directed in the form of input data to two or more nodes. Furthermore, the operator can be a service message directed to a processor. One skilled in the art should understand that the operator to be executed in the EU is not limited by mentioned above exemplary types and can be any operator executable on one or two operands or used for service purposes (for instance, to transmit the service information to a processor or to another component of the computing system).

The computing device comprises a network controller to combine several computing devices into a network. Several computing devices combined into a network can operate together. To ensure maximum efficiency of both the individual computing device and a computing system (see below) it is required to observe the following conditions:.

One computing device or several networked computing devices connected to one or more processors form a computing system cluster. The computing system itself can consist of one or more clusters.

Processors of the computing system cluster can be of any type known in the prior art. Preferably, each processor has a small separate memory with a zero waiting cycle to store local variables of a procedure from a code of a program stored in the processor's RAM-type memory, and a separate memory to store processor instructions. The instruction memory of all processors comprises the same code downloaded from the same address which is processor procedures that can operate in parallel. In such architecture, caches for processor instructions and data in a cluster are unnecessary. Now, all computing devices substantially share the associative memory, and the total performance of the computing system is dependent basically on a data network transmission rate, thus addressing the "memory wall" problem because for such computing system this problem is just irrelevant. Consequently, at a high enough network speed, the total performance of the computing system will increase almost linearly with an increase in the number of the clusters.

One of the clusters in the computing system is a lead cluster and, preferably, is a symmetric multiprocessing system (SMP-system) which loads components of the computing system and executes a program.

The present invention provides the following advantages over the known computing systems and architectures with parallel computations:.

Possible embodiments of the present invention, which however do not limit implementation thereof, will be described in detail below with references to the accompanying drawings.

In general, and according to the first embodiment shown in <FIG>, a computing device <NUM> includes a matching device <NUM> comprising an associative memory <NUM>, at least one executive unit <NUM> (EU <NUM>), a demultiplexer <NUM>, an input network controller <NUM> and an output network controller <NUM>, a message decoder <NUM> and a message encoder <NUM>, a message queue <NUM> and a token queue <NUM>, one or several message and token generators <NUM>, an external device interface <NUM>, and a node table <NUM>.

According to the second embodiment shown in <FIG>, the computing device <NUM> is different from the first embodiment (<FIG>) in that it additionally comprises a RAM-type memory <NUM> (or any similar memory), which is, according to a specific embodiment shown in <FIG>, a component of the matching device <NUM> together with the associative memory <NUM>. Apart from that, said first and second embodiments of the computing device <NUM> are similar.

A major problem of devices operating on the principle of a data flow (data flow mode) including said above known technical solutions is the need to use a hardware associative memory of large volume. This type of memory is energy consumptive and is difficult-to-make. Therefore, it is extremely inefficient and expensive to store large data, for instance data arrays, in the associative memory. This data can be stored in a conventional random access memory, or RAM-type memory, if it is known that this data is available and correct for further computations. In this way, the required capacity of the associative memory <NUM>, which has been already minimized according to the embodiment of the computing device <NUM> according to the present invention shown in <FIG>, can be significantly reduced. The RAM-type memory <NUM> (<FIG>) can store only small number of unpaired tokens required in the current computations to ensure the automatic parallelism.

Here it should be noted that, unlike data stored in the associative memory <NUM>, when certain data is stored in the RAM-type memory <NUM> a pair for this data will not be searched for.

In addition, the computing device can comprise elements not shown in <FIG>, <FIG>, such as a hash function control register comprising information about the total number of computing devices in a computing system and calculating a hash function; a context register comprising information to be placed into a context field of a written token; an index register of a computing device towards which a processor directs data; a status register comprising service information, in particular the information about that a message queue is not empty; a module for computing linear memory addresses, in particular, to implement the second embodiment of the computing device according to <FIG>.

<FIG> shows an embodiment of a computing system based on a plurality of processors <NUM> and computing devices <NUM> connected into several clusters. In particular, <FIG> shows four clusters, each of which comprises three processors <NUM> and four computing devices <NUM>. These clusters are interconnected into one computing system. The transmission between the computing devices <NUM> is conducted by receiving and sending tokens using the input network controller <NUM> and the output network controller <NUM> of each of the computing devices <NUM>.

Referring back to <FIG>, <FIG>, the EUs <NUM> are intended to execute operators on data (operands) of one or two tokens, where an operator, as mentioned above, can be any arithmetic, elementary or service operation on one or two operands.

The information about nodes and connections therebetween used to form and transmit tokens to the EUs <NUM> is stored in the node table <NUM>.

The matching device <NUM> selects an input token from a queue, and using a predetermined input token field (Node_ID field) selects therefrom a row containing a node description from the node table <NUM>. The node description is used by the matching device <NUM> to determine whether or not a paired token needs to be searched for.

If the paired token needs to be searched for, according to the first embodiment of the computing device <NUM> (<FIG>) this search takes place in the associative memory <NUM>. When the paired token is found, the resulted token pair along with the key and the node description key is transmitted to a vacant EU <NUM> for execution, and said found paired token is deleted from the associative memory <NUM> (if it is not forbidden). If the paired token is not found in the associative memory <NUM>, the input token is just written into the associative memory <NUM>.

According to the second embodiment of the computing device <NUM> (<FIG>), the paired token can be stored in the RAM-type memory <NUM> which provides for the following additional advantages.

Parallel computations in the data flow mode are advantageous because of the automatic parallelism of computations at the instruction level in the course of executing an application. On the other hand, a computing graph that represents a data flow algorithm is much less understandable to a software engineer than a typical sequential algorithm, especially when this graph is large. Further, the concept of "scheme" will be introduced and used for the sake of convenience and better understanding of the invention.

A scheme is some kind of a "black box" with inputs and outputs that converts input data into output data. Substantially, the scheme is a small closed (completed) computational graph. When all output data appear as the result of the scheme, this means that the scheme computation executed during computations based on the data readiness principle is completed.

Upon computation completion, the results of such scheme can be loaded into the RAM-type memory <NUM> of the computing device <NUM>, i.e. the RAM-type memory <NUM> will contain data to be used for further computations or transmitted to the adjacent schemes. The schemes can be stored permanently in the node table <NUM> or can be dynamically loaded into the node table <NUM> prior the activation thereof. It is practical to integrate the schemes into a typical sequential algorithm where parallel computations, for instance same-type computations using vector or matrix elements, are required. Accordingly, a program will be some kind of a layered configuration of a linear code and schemes, thus greatly facilitating parallelization of a complex algorithm.

The message decoder <NUM> decodes data inputted via the network and distributes thereof among queues of input tokens and messages.

If the input token does not require a paired token, the data of the input token along with a respective row of the node table <NUM> and the key will be just forwarded (or transmitted) to the EU <NUM> for execution. The result of the operation executed in this EU <NUM> along with the key, the row of the node table <NUM>, and additional parameters, if any, are then transmitted to the message and token generator <NUM>.

The message and token generator <NUM> receives the result from the EU <NUM> along with the context and the row of the corresponding node from the node table <NUM>. The message and token generator <NUM> uses the received data and generates one or several tokens or message, and then sends them to the demultiplexer <NUM> managed by the hash function.

If a computation error occurs (for instance, division by zero), the message and token generator <NUM> generates a message with an error code and accompanying data, if any, and sends this message to the computing device <NUM>. In the computing system comprising two or more computing devices <NUM>, all errors are directed to the same computing device <NUM>, for instance the computing device <NUM> with "<NUM>" index. Said computing device <NUM> with the "<NUM>" index interacts with the processor <NUM> which is the host processor and provides communication between the computing system and the operating system. In particular, the operating system can be launched on this particular host processor. When the error occurs, the computing device <NUM> with the "<NUM>" index directs the error information to the host processor to enable the operating system to end the errant task in all computing devices <NUM> and all processors <NUM> of the computing system where this task has been executed, by directing thereto the respective message, for instance RESET, and directing the error information to a user.

Accordingly, by means of said computing device <NUM> with the "<NUM>" index, the computing devices <NUM> and the computing system can interact with the operating system and, consequently, with the user.

The demultiplexer <NUM> managed by the hash function receives from the message and token generator <NUM> or from the external device interface <NUM> a token or a message with additional parameters. If the demultiplexer <NUM> receives a token, then using the token DataID field and based on the parameters set in the hash function control register, the demultiplexer <NUM> will find an index of a CP core towards which the token is to be sent and transmit this token either to the token queue <NUM> or, together with the found index, to the message encoder <NUM>. If the demultiplexer <NUM> receives a message, then the demultiplexer <NUM> generates a message for the processor <NUM> set in the additional parameters and sends this message to the message encoder <NUM>.

The simplest hash function to find an index can be low-order bits of the DataID field.

The message encoder <NUM> generates a message to be transmitted via the network. It forms a data package containing a token or a message and a recipient core index and sends the formed data package via the output network controller <NUM> to the network.

The external device interface <NUM> provides for communication with the processor <NUM> and forms a token which the processor <NUM> writes down into the computing device <NUM> based on the input signals and the content of internal registers. The token formed according to the calculated hash function is sent either to the token queue <NUM> or in the network, for instance to another computing device <NUM>.

Further examples show the embodiments of the present invention, in particular, the embodiments of computing methods.

<FIG> shows an exemplary embodiment of computations in the data flow mode in the form of a graph, where, for the sake of convenience of understanding of the following description, nodes are designated by references 4a, 4b, 4c which appear to be indices of the nodes. According to the above said, in terms of functionality, the concept of "node" logically corresponds to the concept of "executive unit" (EU) meaning a physical device. Consequently, in this example for simplicity it will be considered that it is a EU (not a node) which actually conducts computations.

In this example, computed is the following expression: <MAT> where a, b, c, d are input data.

Let's assume that the values of a and c are available prior to the values of b and d.

The values of a and c are stored in the associative memory <NUM> or the RAM-type memory <NUM> (depending on the embodiment of the computing device <NUM>) of the matching device <NUM>, while waiting for the computing device <NUM> to receive the values of b and d. As soon as the computing device <NUM> receives the value of b, the matching device <NUM> finds the paired value thereof which is a, determines a vacant node 4a (i.e. a vacant EU 4a, the equivalent of which in this example is assumed as the node 4a), forms a data set which includes, among other, the values of a, b, as well as a multiplication operator which has to be applied to this pair of operands, and directs this data set to the vacant node 4a. In the associative memory <NUM> or the RAM-type memory <NUM> (depending on the embodiment of the computing device <NUM>), the value of a is deleted, unless otherwise is requested.

One of the inputs of the node 4a designated as L receives the value of a, and another input designated as R receives the value of b, the node 4a computes the value of a·b and directs the obtained value to the matching device <NUM>. The node 4a thus becomes vacant. (In fact, computations are executed by the EU 4a that becomes vacant when computations are finished, i.e. EU 4a becomes ready to further receive a new data set to have operations executed on them.

At the same time, or earlier, or later - it depends on when the computing device <NUM> receives the value of d - the matching device <NUM> finds in the associative memory <NUM> or in the RAM-type memory <NUM> (depending on the embodiment of the computing device <NUM>) the value of c, which is a pair to the value of d, and determines the vacant node 4b. It should be noted that at this very moment the vacant node can be the node 4a, e.g. if the computing device <NUM> received the value of d after the node 4a had already finished computing the value of a·b, or if the computing device <NUM> received the value of d before receiving the value of b. Important is that the data set which is full (sufficient) to execute operations thereon is directed to the currently vacant node.

To be specific, let's assume that when the data set including values of c and d was formed, the node 4a was used (EU 4a was busy with computation), and this is why the data set would be directed to the node 4b. The value of c is directed to one input of the node 4b designated as L, and the value of d is directed to the second input R of the node 4b. In the associative memory <NUM> or in the RAM-type memory <NUM> (depending the an embodiment of the computing device <NUM>), the value of c is deleted, unless otherwise is required. A result obtained upon the computation of the value of c:d is directed to the matching device <NUM>, and the node 4b thus becomes vacant.

So, the values of a·b and c:d are computed independently from each other.

As soon as the node 4a (like any other node) does not compute the value of a·b anymore, it can be used for further computations. It should be also noted that the node 4a is not limited to only the multiplication operation, rather it can also execute any operation indicated by the computing device <NUM>, in particular, the operation indicated in the node table <NUM> for specific operands.

The node 4b operates likewise: as soon as it does not compute the value of c:d anymore it can be used for further computations. The node 4b is not limited to only the multiplication operation, rather it can also execute any operation indicated by the computing device <NUM>, in particular, the operation indicated in the node table <NUM> for specific operands.

Now, to be specific, let's assume that the node 4a had computed the value of a·b before the node 4b computed the value of c:d, i.e. the value of a·b entered the matching device <NUM> before the value of c:d. When the value of a·b is received, the matching device <NUM> searches in the associative memory <NUM> or in the RAM-type memory <NUM> (depending on the embodiment of the computing device <NUM>) for the value of c:d and, not finding it, puts the value of a b into the associative memory <NUM> or in the RAM-type memory <NUM>, respectively (depending the an embodiment of the computing device <NUM>). Next, as soon as the matching device <NUM> receives from the node 4b the computed value of c:d, the matching device <NUM> searches in the associative memory <NUM> or in the RAM-type memory <NUM> (depending the an embodiment of the computing device <NUM>) for the computed value of a·b, finds it, forms a data set including a pair of computed values of a·b and c:d and an addition operator (addition, i.e. "+"), and directs this data set to the currently vacant node 4c. If the node 4a and/or the node 4b is currently a vacant node, each of them can be the node 4c. The associative memory <NUM> or the RAM-type memory <NUM>, respectively, (depending on the embodiment of the computing device <NUM>) deletes the value of a·b, unless otherwise is required.

The node 4c receives the data set, computes the value of the expression of a·b + c:d and sends it to the matching device <NUM>.

Thus, the nodes 4a, 4b, 4c each is used independently without waiting for computations executed by the other nodes at the other steps of the procedure. As soon as the matching device <NUM> receives all necessary data for a specific operator to be applied thereon, the computing device <NUM> selects a vacant node and directs a data set thereto. When the computations are executed, said vacant node sends the received result back to the matching device <NUM> and becomes free.

Given the small size of the graph shown in <FIG>, this graph can be considered as a scheme, as defined above.

<FIG> shows, in the form of a graph, an example of the fine-grain parallelization to find the X1, X2 roots of a quadratic equation <MAT> using the described above principle of computation in the data flow mode and implemented in the computing device <NUM> according to the present invention. <FIG> shows the following operator designations:.

<FIG> shows an embodiment of filling the node table <NUM> according to the example of <FIG>. In <FIG>, operator designations correspond to the designations described above with reference to <FIG>, and are accompanied with the following designations:.

Similarly to the described above example <NUM> of the principle of computations in the data flow mode (<FIG>), for simplicity it will be considered that operators are executed in nodes which are functionally similar to the EUs <NUM>. To better understand the example, in <FIG> the nodes are accompanied by the designations of arithmetic operators given in brackets.

The processor <NUM> of the computing system transmits the values of a, b, c to a selected computing device <NUM>.

The operand duplication operator in the node <NUM> (NOP) duplicates the value of b and directs these values to the nodes <NUM> (NEG) and <NUM> (MULT). In the node table <NUM> of the node <NUM> (NOP), it is said that:.

The operand duplication operator in the node <NUM> (NOP) duplicates the value of a and sends these values to the nodes <NUM> (MULT) and <NUM> (MULT). In the node table <NUM> of the node <NUM> (NOP), it is said that:.

In the node <NUM> (NEG), the inversion operator assigns the opposite sign to the value of b, i.e., it forms the value of -b and send this result to the nodes <NUM> (SUB) and <NUM> (ADD). According to the node table <NUM>, the result of -b will be send to the node <NUM> to the input L thereof (see the POS1 field).

In the node <NUM> (MULT), the operator multiplies the obtained value of b by the obtained value of b and sends the result of b<NUM> to the node <NUM> (SUB). The node table <NUM> prescribes the node <NUM> to use the first operand value (SOL field has the value of "<NUM>") as the second operand, and the result is sent to only one node (the O2 field contains a line), specifically, to the node <NUM> (see the O1 field) to the input L thereof (see the POS1 field), wherein only one output of the node <NUM> is involved (the OE2 field has the value of "<NUM>").

In the node <NUM> (MULT), the operator multiplies the obtained value of a by the value of c and directs the result of a·c to the node <NUM> (MULT). The node table <NUM> comprises the information for the node <NUM>, according to which the second operand, namely the value of c, is located in the associative memory <NUM> (the SOL field has the value of "<NUM>"), and the result will be directed from one output (the OE2 field has the value of "<NUM>") to the input L of the node <NUM>.

In the node <NUM> (MULT), the operator multiplies the obtained value of a by the obtained value of <NUM> and directs the result of <NUM>·a to the node <NUM> (DIV). The node table <NUM> comprises the information for the node <NUM>, according to which the second operand, namely the constant of <NUM>, is in the data field (the SOL field has the value of "<NUM>" ), and the result from both outputs (the OE1 and OE2 fields each has the value of "<NUM>") will be sent to the inputs R (see the POS1, POS2 fields) of the nodes <NUM>, <NUM> (see the O1, O2 fields).

The node <NUM> (MULT), having obtained (probably, in advance) the value of <NUM> and received the result of α·c from the node <NUM> (MULT), multiplies and sends the result of <NUM>·a·c to the node <NUM> (SUB). The node table <NUM> comprises the information for the node <NUM>, according to which the second operand, namely the constant of <NUM>, is located in the data field (the SOL field has the value of "<NUM>"), and the result from one output (the OE2 field has the value of "<NUM>") will be sent to the input R of the node <NUM>.

The node <NUM> (SUB), having obtained the value of b<NUM> from the node <NUM> (MULT) and the value of <NUM>·a·c from the node <NUM> (MULT), subtracts said second value from said first value and sends the result of b<NUM>-<NUM>·a·c to the node <NUM> (SQRT), to calculating a square root of (b<NUM>-<NUM>·a·c)<NUM>/<NUM> and further transmitting this result to the nodes <NUM> (SUB) and <NUM> (ADD). The node table <NUM> comprises the information for the node <NUM>, according to which the second operand, namely the result of computations in the node <NUM>, is located in the associative memory (the SOL field has the value of "<NUM>"), and the result from only one output (the OE2 field has the value of "<NUM>") will be directed to any input of the node <NUM>, since only one input of the node <NUM> is used. The node table <NUM> comprises the information for the node <NUM>, according to which the second operand is unavailable (the SOL field has the value of "<NUM>"), and the result from both outputs (the OE1 and OE2 fields each has the value of "<NUM>") is directed to the inputs R (see the POS1, POS2 fields) of the nodes <NUM>, <NUM> (see the <NUM>, <NUM> fields).

Having received the value of (b<NUM>-<NUM>·a·c)<NUM>/<NUM>, the node <NUM> (SUB) substrates this value from the value of -b received from the node <NUM> (NEG), while the node <NUM> (ADD) adds said value to the value of -b received from the node <NUM> (NEG). The node <NUM> (SUB) and node <NUM> (ADD) direct their computation results to the node <NUM> (DIV) and the node <NUM> (DIV), respectively. Descriptions in the fields of the node table <NUM> for the nodes <NUM>, <NUM> can be understood from the described above and therefore is omitted.

The nodes <NUM> (DIV) and <NUM> (DIV) divide the values of -b-(b<NUM>-<NUM>·a·c)<NUM>/<NUM> and - b+(b<NUM>-<NUM>·a·c)<NUM>/<NUM> received from the nodes <NUM> (SUB) and <NUM> (ADD), respectively, by the value of <NUM>·a received from the node <NUM> (MULT). The results of the division operator in the nodes <NUM> (DIV) and <NUM> (DIV) are roots X1 and X2 of the quadratic equation, respectively, which are further transmitted to the node <NUM> (OUT) and the node <NUM> (OUT), respectively, where said roots are added with the service information. This service information and the value of the roots X1 and X2 of the quadratic equation in the form of tokens is transmitted to the computing device <NUM>, and further to the processor <NUM>. Descriptions in the fields of the node table <NUM> for the nodes <NUM>, <NUM> can be understood from the described above and therefore is omitted.

The node table <NUM> causes the nodes <NUM> (OUT) and <NUM> (OUT) to send the values of the roots X1, X2 of the quadratic equation to the CPU processor.

Although in the described example of computation of quadratic equation roots <NUM> nodes have been used, it should be understood that in terms of implementation fewer EUs <NUM> would be enough, and this should not cause reduction of the total computation speed.

For instance, according to the above described, the EU <NUM> corresponding to the node <NUM> (MULT) is used at the very beginning of the program where values of <NUM> and a are multiplied. When the values of <NUM> and a are obtained, and multiplication operations for said values are executed, and the calculated value of <NUM>·a is transmitted to next nodes, the EU <NUM> corresponding to the node <NUM> (MULT) becomes vacant (free), a record of which will be written in the node table <NUM>. Further, the computing device <NUM> can assign, for instance, the operation of subtraction of the value of <NUM>·a·c from the value of b<NUM> (the node <NUM> (SUB)) to the same EU <NUM> which has already become vacant upon the computation operation indicated in the node <NUM> (MULT), provided that by the time the value of b<NUM> from the node <NUM> (MULT) and the value of <NUM>·a·c from the node <NUM> (MULT) are ready, the EU <NUM> will be indeed vacant (i.e. not busy with a new calculation).

Similarly, during computations, any other vacant EU can be used multiple times. Thus, the EUs executing operations at the beginning of the program which correspond to the nodes <NUM> (NOP) and <NUM> (NOP), can be further used to execute operations corresponding to any other nodes, for instance, the nodes <NUM> (MULT), <NUM> (SUB), <NUM> (SUB), <NUM> (ADD), <NUM> (DIV) and <NUM> (DIV), <NUM> (OUT), <NUM> (OUT).

In general, the computing device <NUM> can comprise only one EU <NUM> which will execute all operations described above, although by no means this will affect the number of the nodes in the graph shown in <FIG>. In this case, the fine-grain parallelization of computations can be arranged by combining several computing devices <NUM> into a network to form the computing system. For instance, the node <NUM> (NOP) may be the component of the first computing device <NUM>, the nodes <NUM> (NOP) and <NUM> (MULT) - of the second computing device <NUM>, the nodes <NUM> (NEG), <NUM> (MULT) and <NUM> (MULT) - of the third computing device <NUM>, and so on. This will not cause any errors because, as mentioned above, the tokens with similar keys should be sent to the same computing device <NUM> (otherwise the paired tokens will never meet each other), and node tables <NUM> of the computing devices <NUM> combined to one computing system by the network are identical.

Nevertheless, when using the computing devices <NUM> with a single EU <NUM>, the computing system performance is to some extent defined by the rate of data transfer on the network. Therefore, it is preferable that each computing device <NUM> comprises two or more EUs <NUM>. Unlike the known solutions, such as a vector processor, the EUs <NUM> at each given time execute different instructions (operators). Computations are carried out based on the readiness of data using the associative memory <NUM> to map the operands in accordance with the computing graph stored in the node table <NUM>. Each row of the node table <NUM> contains details of the operation in the node, operation options, input operands, rules of result formation and return, sending the results to other nodes.

The graph shown in <FIG> is quite complex and, although it can be considered as a scheme, it is unpractical in terms of the present invention.

In the exemplary computations described above, the small amount of data is processed which, in addition, does not comprise many similar operations. Consequently, the RAM-type memory <NUM> in the computing device <NUM> (see <FIG>) is not mandatory, and it is possible to use only the associative memory <NUM> both to store the intermediate computational values of expressions and/or the operands which currently require the second operand and to process the data and the results.

However, in some cases, the RAM-type memory <NUM> in the computing device <NUM> gives important advantages during parallel computations, in particular, during different operations with vectors and matrices, i.e. during processing of large data arrays. For such particular computations, it is advantageous for the computing device <NUM> to comprise a module for computing linear memory addresses in the format of (Row,Col). As mentioned above, in this case the node table uses the fields for each output of the node which direct the resultant token to the adjacent schemes. In general, the scheme may have several inputs and outputs and, accordingly, can transfer the data between different cells of the computing matrix, not only between the adjacent ones.

It is preferable, if during processing of the large data arrays, the associative memory <NUM> is used not to store the data, but to store the intermediate computation results. In this case, the processed data and the results are stored in the RAM-type memory <NUM>. This is one of the reasons why the token includes, preferably, the DataID field which is the identifier of the second operand data.

Besides, the structure of the token and the node table can be expanded with additional fields, if necessary.

For instance, a "Fast Result" bit can be added to the row of the node table <NUM> for each of the outputs. If this bit is set, and the node does not require a value of an operation result to form a token, then such token is formed immediately without waiting when the operation is finished. This makes it possible to increase the number of launched instructions per a predetermined time interval.

So, when large data arrays are required to be processed, it is preferable to use the RAM-type memory <NUM>, rather than the associative memory <NUM> to store the data (although the latter is still possible). In addition, the associative memory <NUM> is preferably used to store the intermediate operational results of the schemes executed based on the data readiness. For instance, computations of multiplication (a product) of matrices require to having one cell of the associative memory <NUM> per each element of a resultant matrix. For simultaneous computation of <NUM> values of the resultant matrix, it is totally required <NUM> cells of the associative memory <NUM> to accumulate the sum of productions. In general, computations are executed between the input token data and the cell of the associative memory <NUM> addressed for the token by the index of the row of the token key. This provides for a drastic reduction of required volume of expensive, complex and energy consumptive associative memory <NUM> in the computing device <NUM>.

According to said embodiment of the computing device <NUM> (<FIG>), the instruction system allows arranging cycles and controlling the output therefrom. This means that the resultant token on each of the outputs is transmitted (or not transmitted) to the other scheme depending on a condition whether or not the indices defined in the DataID field of the output token are within predetermined ranges defined in the row of the node table. Conditional transmissions by means of conditional statements can be also used, but often they are less efficient.

To illustrate advantages of the associative memory <NUM> and the RAM-type memory <NUM> in the matching device <NUM>, further examples of computations with the use of the computing device <NUM> according to <FIG> are described below.

<FIG> shows a computing matrix for parallel computations of a sum of elements of a matrix (M, N), where the following designations are used:.

The matrix elements are stored in the RAM-type memory <NUM>.

Computations are executed in the following order.

Elements A[<NUM>, <NUM>], A[<NUM>, <NUM>], A[<NUM>, <NUM>],. A[<NUM>, N-<NUM>] of the matrix row are selected and sent (transmitted) for summing "downwards" along the column. The LOAD instruction reads the data (of specific matrix elements) from the RAM-type memory <NUM> according to the address defined in the fields [Row, Col] of the input token and forms a token according to rules defined by the instruction.

Next, the value of matrix element A[x, y] is added in each column to the value sent "from above" (Result), and the result is transmitted to the associative memory <NUM>. For instance, the value of A[<NUM>, <NUM>] is added to the value of A[<NUM>, <NUM>] (Result) sent "from above"; the resulted value (Result) is added to the value of A[<NUM>, <NUM>], and so on. For that, the MADD instruction sums up the input token with the RAM-type memory <NUM> content which is addressed to the fields [Row,Col] of the input token. The result of this column summing, i.e. the sum of the column elements, is written to the associative memory <NUM>.

Further, the sum values of the column elements of each of the columns are summed up (the ADD instruction). The summing result for all matrix elements is written to the associative memory <NUM> or to the RAM-type memory <NUM>, depending on further actions with this result according to the procedure being executed.

According to the mentioned above, the parallel computation algorithm of summing of matrix elements is carried out by means of three scheme: the first scheme being the selection of a matrix element, the second scheme being the summing of a value of the matrix element with a value "from above" (a value of the previous matrix element), and the third scheme being the summing of the obtained sums of the elements in columns. Each scheme consists of one instruction. The original data, due to a large volume thereof, are located in the RAM-type memory <NUM>, and the intermediate data can be stored either in the associative memory <NUM> or in the RAM-type memory <NUM>.

<FIG> shows another variant of a node table for parallelization of adding (summing) elements of a matrix (M, N) and respective start tokens, wherein the matrix elements are stored in the RAM-type memory <NUM>. In addition to the above mentioned, the following designations are used in this example:.

Computation is carried out in the following order.

The computation algorithm includes calculation of sums of the elements in each row, followed by summing up said sums. The algorithm comprises four schemes, Scheme <NUM> to Scheme <NUM>, each of which is given in the note table as a single row.

Scheme <NUM> selects each element A[<NUM>,j] from the <NUM>-th row of the matrix using the field DataId as an address in the RAM-type memory <NUM> and transmits it down to the column j to Scheme <NUM> through the output OUT2 while increasing the value of the field DataID. Row of the output token by <NUM>.

Along with that, at the output OUT1 a token is being formed which value of the field DataID. Col is increased by <NUM> for selecting the next element in the current row, and this token is forwarded to Scheme <NUM>, i.e. to itself, thus forming a cycle. Exit from said cycle (i.e. finishing with generation of tokens at this output) is carried out when the value of the field DataID. Col is out of the range given in the field Dim. Col of the row of the node table for Scheme <NUM>.

The field Addr of the node table comprises the address of the matrix A, while the fields DimR and DimC comprise the number of rows and columns of the matrix A, respectively.

Scheme <NUM> sums up the data coming from the "above" of the row j with the element of A[ij] and increases the value of the field DataID. Row of the result token by <NUM>.

If the field DataID. Row of the token is not beyond the upper limit of the field DimR of the row of the node table, the result token is forwarded to Scheme <NUM> (i.e. to itself), thus forming a cycle for accumulating the sum. Otherwise, the token is forwarded to Scheme <NUM>.

Scheme <NUM> sums up the received values of the sums of each of the columns and increases the value of the field DataID. Col of the result token by <NUM>.

If the field Data. Col of the token is not beyond the upper limit of the field DimC of the column of the node table, the result token is forwarded to Scheme <NUM> (i.e. to itself), thus forming a cycle for accumulating the sum. Otherwise, the token with the field DataID=<NUM> is forwarded to Scheme <NUM>.

Scheme <NUM> stores the received result in the RAM-type memory <NUM> under the address SUMMA_A.

The field Addr of the node table comprises the SUMMA_A, while the fields DimR and DimC have the value <NUM>.

Note that all intermediate results (data) are stored in the associative memory <NUM>.

To launch the above described computation the host processor forwards two tokens:.

While Example <NUM> described above can be implemented using known computing devices, though not so efficiently, Example <NUM> shows clear advantage of the present invention over all known computing devices and methods.

The above computing device or computing system comprising such computing devices can be implemented on any known hardware/software solution. For instance, these can be implemented by means of Programmable Logic Device (PLD). Processors can be processors with any known architecture, such as ARM, MIPS, SPARC, X86, etc..

The embodiments of the computing device disclosed above allow for implementation of various parallel computation algorithms, the general advantages of which include simple programming, no need to support the coherence of data cache and data cache availability in general, no deadlocks and "Memory Wall" problems, high speed of calculations, easy and highly-efficient scaling of the computing system.

Claim 1:
A computing device (<NUM>) for execution of a procedure, in particular a procedure that may be schematically represented in the form of a graph having nodes, wherein said nodes are operators of the procedure, the computing device (<NUM>) comprising:
- at least one executive unit (<NUM>) to execute operations on input data given in the form of tokens, wherein each of the executive units (<NUM>) is connected to a message and token generator (<NUM>) forming output data in the form of tokens,
- a node table (<NUM>) storing a description of each node of the graph and connections between nodes which are used to form and transmit tokens to the at least one executive unit (<NUM>), the node table (<NUM>) comprising at least the following information for each node of the graph:
▪ a node index,
▪ a number of input data of the node,
▪ a number of output data of the node,
▪ an operator of the node applied by the node to the input data of the node, and at least one index of a further node to which the node, having executed the operator, sends the output data of the node,
- a matching device (<NUM>) comprising an associative memory (<NUM>) and configured for using the description of the nodes in the node table to store the input data, to search for the input data, and to send to the executive units (<NUM>) the input data specifically intended for these executive units (<NUM>),
- a message queue (<NUM>) and a token queue (<NUM>),
- a demultiplexer (<NUM>),
- an input network controller (<NUM>) and an output network controller (<NUM>),
- a message decoder (<NUM>) and a message encoder (<NUM>), and
- an external device interface (<NUM>).