JP3472913B2 - Load balancing method for reconfigurable hardware - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention, in reconfigurable hardware, dynamically distributes the processing load of an object by generating a duplicate object of its own object, and makes the resources of the reconfigurable hardware effective. The present invention relates to a load balancing method that can be used.

[0002]

2. Description of the Related Art Reconfigurable hardware that is rewritable hardware (FPGA (Field Program)
RAMMABLE GATE ARRAY) and PLD
(Programmable Logic Device
e) and the like) are often used for prototyping before making a static LSI such as an ASIC (application-specific IC) or for making a small amount of LSI at low cost. For example, in an FPGA, the user can program 2
Logic of about 000 to tens of thousands of gates can be realized, and it has been used for a prototype for logic verification for designing a gate array, or for small-scale production of 1000 or less. Further, in the PLD, an array of AND gate groups and O
The logic circuit is easily realized by cutting the fuse connecting the gates, which is composed of an array of R gate groups. On the other hand, by taking advantage of the rewritability, it is also used to rewrite the hardware to change the function that was conventionally realized by changing the software. However, the greatest advantage of performing processing directly by hardware is that it can be processed in parallel with other processing in arbitrary units. Focusing on this point, PCA (Plastic Cell Ar) that is reconfigurable hardware
Constraint Satisfaction Problem (CSP: Constrain Satin)
A method for solving the saction problem has been proposed (Shiozawa, Oguri, Nagami, Ito, Konishi, "Reconfigurable LSI architecture realizing general-purpose computing mechanism" IEICE Technical Report [VLSI design technology], VL.
D97-114, March 1998).

Before describing the constraint satisfaction problem, an outline of PCA, which is reconfigurable hardware used in this problem, will be described. As shown in FIG. 7, the PCA includes uniform cells 10 connected to each other, and each cell includes a built-in part 11 and a plastic part 12. The built-in unit 11 has a predefined fixed function and is connected to the built-in unit 11 between adjacent cells via a line. The plastic section 12 is a programmable logic that can be rewritten in cell units, is a logic circuit that is connected to the plastic section 12 of the adjacent cell 10 and can be used as a logic gate or a storage element (see FIG. 11). . This PCA is a conventional PLD, FP
The difference from GA and the like is that the rewriting of the plastic part 12 is carried out autonomously and in parallel by the PCA itself. This not only has the advantage of reducing the overhead of rewriting due to the intervention of the processor, but also rewriting P
There is also an advantage that it can be realized in parallel inside the CA. A unit of function realized by rewriting PCA is called an object.

FIG. 8 is a diagram showing a cycle from the generation of an object to its disappearance inside the PCA. PCA
Then, when a new object is generated, a rectangular empty area is searched using a message propagated / reflected between the embedding units 11 of each cell. When a vacant area is found, the area is secured (step 21), the circuit configuration information is transmitted to the area as a message, and the circuit information is written and the circuit is activated (step 22). This completes the generation of the object. The generated object transits its internal state while exchanging messages with other objects (step 24) (step 2).
5) If necessary, the processing result is sent as a message to another object (step 24). When the object receives the area release message, the object stops and sequentially releases the cell areas forming the object (step 26). Thus, in the PCA, the built-in unit 11
Objects are autonomously created / erased using the functions prepared in advance, and the created objects become hardware functional blocks that can operate independently.

In the following, a case where a plurality of objects perform processing while transmitting and receiving a message on reconfigurable hardware will be described using an example of solving a constraint satisfaction problem (CSP). The constraint satisfaction problem (CSP) is a problem that formulates many problems such as artificial intelligence processing and natural language understanding, and is defined as follows, as shown in the Technical Report of the Institute of Electronics, Information and Communication Engineers mentioned above. To be done. n (≧ 1) variables x
₁ x _2, there is · · xC, finite set each D ₁ D ₂ as the value, when given in · · DC, assign values to n variables based on the constraints given below. Variable set tO = (xI, ... xI) (1 ≦ i
The set of values that can be assigned to <j ≦ n) is the constraint RO =
{(U, ... v) ∈DI × ·· × DI | (u, ...
v)}, all constraints RO (1 ≦ k ≦ m)
For {(d ₁ , d ₂ , ..., dC) ∈ D ₁ × D ₂ × ...
× Dn | (dI, ... dI) εRO} satisfying the set (d
It is a problem to obtain ₁ , d ₂ , ..., dC). A set of tO and RO (tO, RO) is particularly called a constraint condition.

The constraint satisfaction problem (CSP) includes a case of obtaining all pairs (all solution search) and a case of obtaining one solution (single search). An example of the Constraint Satisfaction Problem (CSP) and all its solutions are given below. [Example of Constraint Satisfaction Problem (CSP)] Variables: x ₁ , x ₂ , x ₃ , x ₄ , x ₅ Range: D ₁ = D ₂ = D ₃ = D ₄ = D ₅ = {a, b, c, d, e} Constraints: t ₁ = (x ₁ , x ₂ ), t ₂ = (x ₁ , x ₃ , x ₄ ), t ₃ = (x ₂ , x ₄ ), t ₄ = (x ₂ , x ₅ ) R ₁ = {(a, b), (b, a), (b, e)} R ₂ = {(b, b, e), (b, c, a), (c, b, e)} R ₃ = {(e, a), (a, d), (a, e)} R ₄ = {(e, d), (a, d), (d, a)} Solution: ( b, a, b, c, d) and (b, e, c, a, d)

FIG. 9 shows the configuration of reconfigurable hardware.
Solves the constraint satisfaction problem example with 5 objects
It is a figure which shows an example. CPS on reconfigurable hardware
To solve the starting object (object 10
1) and each constraint condition (t₁, R₁), (T₂, R₂),
..A constraint object generated for each (tU, RU)
To generate. The arrows in Fig. 9 indicate messages between objects.
Indicates the transfer direction of the data. The kth constraint object is the
The value is assigned to the variable from the (k-1) th constraint object.
Assigned group (d₁, D₂, ..., dC) message
To receive as. However, the value corresponding to each variable is undefined
A value ('u') may be assigned. No. k
The eye constraint object has a constraint on its own object.
Assign a value to a variable that has an indefinite value so as not to shield
It If such an assignment exists, it is newly obtained
Set (d₁’, D₂', ..., dC') as a message
Send to the (k + 1) th constraint object. For variables
And there is no value assignment that satisfies the constraint
To discard the received message (Object 1
03). Start object is the first constraint object
A set in which indeterminate values are assigned to all variables
Send and then send the end message (object
101). The last constraint object, mth
From the constraint object of (d
₁’, D₂', ..., dC') is transmitted (object
105). Also, the constraint object that received the end message
JECT forwards the end message to the next object
To do.

The starting object is the set (d ₁ ', d ₂ ',
.., dC '), if the solution to be sought is a single solution search, the other object is deleted, and if it is a full solution search, it stops when the end message is received. Also,
If the end message is received without receiving the pair, there is no answer. Here, the sub-problems of the given problem are assigned to objects (constraint objects) that can operate in parallel, and processing is performed, and finally variable assignments that do not contradict each other can be obtained. According to this method, the subproblems assigned to each constraint object are processed in parallel, but when the size of the RO of the constraint condition is large, it takes time to process with the constraint object, and parallelism can be sufficiently drawn out. There is a problem that there is no.
Therefore, as a method of eliminating such uneven load, a method of dividing a partial problem and assigning it to objects that can operate in parallel has been proposed in the above-mentioned technical report of the Institute of Electronics, Information and Communication Engineers. FIG. 10 is a diagram showing an example of a conventional technique in which a load is distributed by five objects configured on reconfigurable hardware. Here, the above C
In the SP example, the load is distributed by dividing R ₃ into two to form R ₃ ′ and R ₃ ″.

[0009]

As described above, an example of solving the constraint satisfaction problem and an example of load balancing on reconfigurable hardware have been described. However, as shown in FIG. 11, reconfigurable hardware can be used. A method in which a plurality of objects configured as described above perform a series of processes while exchanging messages with each other can be seen in conventional processes (see, for example, Japanese Patent Application No. 10-98657 and drawings). . For example, when selecting a route for communication or transportation, there is a problem of selecting a route from a plurality of routes existing between two points. Due to the current usage (congestion) condition, temporary restrictions due to construction, etc., and cost constraints. When selecting the most suitable route at the moment, the situation and regulations are used as constraint objects,
The problem can be solved by further providing an object for calculating the cost of the route obtained from the result. Figure 1
In the case of 1, there is an object 1 made up of 20 cells including the cell 31 and an object 2 made up of 6 cells including the cell 35. In this example, a case where a communication path is secured between the cell 31 of the object 1 and the cell 35 of the object 2 and a message is transmitted from the object 1 to the object 2 is shown. From cell 31 to cell 32, routing information and messages are output sequentially in the order of W selecting the left cell, then SSSSS selecting the lower cell, and EEEE selecting the right cell. It Cell 32 removes the information of selection W and sends out only the routing information from cell 32. In this way, the cells 33 and 34 can also sequentially transmit the message from the object 1 to the cell 35 by using the route information.

However, as described above, in the conventional method for performing load distribution, the load is stochastically distributed because it is performed by dividing the object corresponding to the subproblem. It is difficult to predict in advance whether the load can be distributed most by dividing it. In particular, even in the above example of the constraint satisfaction problem (CSP), when the partial decomposition candidate RO is explicitly given as an enumeration type, if the partial decomposition candidate set RO is divided, a tentative load distribution is achieved. Although it can be achieved, if given by a conditional expression (for example, a conditional expression such that all values of R ₃ are x ₂ ≠ x ₄ with respect to t ₃ ), the conditions are divided. It is difficult to balance the load. In addition, there is a problem that it is necessary to suspend the processing being executed by the object in order to perform the division or the combination after the overloaded state is resolved.
Therefore, an object of the present invention is to solve such a problem, to distribute the load by duplicating objects instead of dividing the objects configured on the reconfigurable hardware,
Another object of the present invention is to provide a load balancing method for reconfigurable hardware that can effectively allocate resources of reconfigurable hardware to an overloaded process without causing interruption of the process. .

[0011]

In order to achieve the above object, in a load balancing method for reconfigurable hardware according to the present invention, (1) a plurality of objects are configured as circuits on the reconfigurable hardware, In the load balancing method in the reconfigurable hardware that executes a series of processes by transferring the processing result performed by each object as a message to another object, the object uses a means for detecting an overload state, When the overload state is detected by the detection means, the own object is fixed in the free area on the reconfigurable hardware.
By sending object configuration information Yu, and transferred to the own object to generate a replication object, newly generated the duplicated objects some or all of the message that is to wait for work own objects, the Run it on a duplicate object. (2) In the method of (1) above, instead of the overload state detecting means, a means for detecting that the object is overloaded is used, and the object detects that the overloaded state is cleared. , Delete the duplicate object of the self object. (3) In the method of (1) or (2) above , when the object in which the composite object exists detects the cancellation of the overload condition or receives a deletion message from another object, When a duplicate object exists, it sends a message to delete the duplicate object created by itself, and if the duplicate object does not exist, deletes it from other objects.
When the message is received, the object that has sent the delete message is notified that the object has been deleted, and then the object is deleted.

[0012]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described in detail below with reference to the drawings. FIG. 1 is a functional block diagram of an object showing a first embodiment of the present invention. In FIG. 1, reference numeral 401 is an object on reconfigurable hardware, 402 is a message transmitting / receiving unit for communicating with other objects, and 403 is an overloaded state of processing by this object. An overload detection unit 404 performs a process for generating a process equivalent to this object in an unused area on the reconfigurable hardware, and a reference number 405 denotes an object processing unit that performs a process unique to this object. is there.

FIG. 2 is a processing flowchart for performing load distribution with the objects shown in FIG. The message received from another object is notified to the object processing unit 405 via the message transmitting / receiving unit 402. If the object processing unit 405 can process the message notified from the message transmitting / receiving unit 402,
At the same time as notifying that the message has been received to the message transmitting / receiving unit 402, processing corresponding to the content of the received message is performed. The message transmission / reception unit 402 notifies the overload detection unit 403 of the number of messages (process waiting messages) for which the notification that the message has been received from the object processing unit 405 has not been received among the messages received from the outside at that time. (Step 501).

The overload detection unit 403 determines that this object is overloaded when the number of processing waiting messages notified from the message transmission / reception unit 402 exceeds a predetermined number (step 502). Copy generation unit 40
4 tell it to create a duplicate of this object. The copy generation unit 404 can generate a copy of this object from a free area on the reconfigurable hardware for a free area management object that is a special object that manages resources on the reconfigurable hardware. A request is made to secure an area (step 503). If the free space is successfully secured (step 504), the object common unit (for example, the message transmission / reception unit 402, the overload detection unit 403, the copy generation unit 404, etc.) that is a part common to the objects in the secured free space, A part that is common to the objects, but the range included in the object common part is instructed to generate (step 50).
5).

Further, the object configuration information unique to the object is read from the object processing unit 405,
The configuration information of the object processing unit 405 is transferred to the duplicate object (step 506). For the duplicate object, the duplicate generating unit 404 writes this in the secured area in the form of a message to generate a duplicate of the object. After the copy of the object is generated, a part of the message waiting to be processed in the message transmitting / receiving unit 402 is transferred to the newly generated object (step 507). In this example, the overload detection unit 403
It judges that this object is overloaded when the number of pending messages exceeds the predetermined number, but it can be reconfigured by creating a new object in an overloaded state for an extremely short time. In order not to waste the hardware area, a counter or the like is provided in the overload detection unit 403, and when the number of messages waiting to be processed exceeds the predetermined number continuously for the period of the counter, There is also a method of determining the load. Further, in this embodiment, the overload is detected by the number of messages waiting to be processed from other objects. However, the number of processes in the waiting state occurring in the processing process in the own object is calculated from other objects. It is also possible to detect the overload state caused by the own object by handling it in the same manner as the number of processing waiting messages.

By using the method of the first embodiment described above, when an object is overloaded with respect to the processing uniquely performed by each object, the processing of its own object is not divided but overloaded. By generating a copy of the object in the loaded state, the load in the processing waiting state can be distributed, so that the load can be distributed without dividing the object. In addition, by disposing the configuration information of the object processing unit 405 so that it can be read from the copy generation unit 404 during operation (for example, the hardware configuration information has a 2-port memory configuration), the processing on the object is interrupted. It is also possible to create a duplicate object instead.

FIG. 3 is a functional block diagram of an object showing a second embodiment of the present invention. In FIG. 3, 6
01 is an object on reconfigurable hardware, 60
2 is a message transmitting / receiving unit for communicating with another object, 603 is an overload elimination detecting unit for detecting that an overload condition for processing performed by this object has been eliminated, and 604 is an object reconfiguration by deleting the object. An annihilation processing unit that performs processing for setting an unused area on the hardware, and an object processing unit 605 that performs processing unique to this object. This object is an object that causes the duplicated object to disappear when the overloaded state is resolved.

FIG. 4 is a processing flowchart for extinguishing the object whose overloaded state in FIG. 3 has been resolved. Messages received from other objects are
The object processing unit 605 is notified via the message transmitting / receiving unit 602, and if the object processing unit 605 can process the message notified from the message transmitting / receiving unit 602, the object processing unit 605 notifies the message transmitting / receiving unit 602 that the message has been received. At the same time, the processing according to the content of the received message is performed. The message transmission / reception unit 602 notifies the number of processing waiting messages to the overload elimination detection unit 603 (step 701). The overload elimination detection unit 603 determines that the overload state of this object is determined when the number of process waiting messages notified from the message transmission / reception unit 602 does not exceed a predetermined number for a certain period of time measured by a counter or the like. It is determined that the object has been resolved (step 702), and the disappearance processing unit 604 is notified to erase the duplicated object of this object. The disappearance processing unit 604 notifies the empty area management object via the message transmission / reception unit 602 of a message to delete the duplicate object together with information that can uniquely identify the duplicate object.

In the present embodiment, the detection of the elimination of the overload state is carried out by the number of process waiting messages from other objects. However, the process in the waiting state occurring in the processing process in the own object It is also possible to detect the elimination of the overload state caused by the own object and to instruct the free space management object to delete the own object by treating the number of the same as the number of messages waiting to be processed from other objects. It is possible. As described above, by using the method of the second embodiment, the duplicate object generated by the method of the first embodiment in order to eliminate the overloaded state is deleted when the overloaded state is eliminated. Therefore, it is possible to effectively use the resources for deleting the unnecessary objects and generating the necessary objects on the reconfigurable hardware.

FIG. 5 is a functional block diagram of an object showing a third embodiment of the present invention. In FIG. 5, 8
Reference numeral 02 denotes a message transmitting / receiving unit for communicating with another object, 803 denotes an overload elimination detecting unit for detecting that an overload state for processing performed by this object has been eliminated, and 804 deletes the object and reconfigures it. An extinction processing unit that performs processing for making an unused area on hardware, 805 is an object processing unit that performs unique processing of this object, and 806 is a value “1” when a duplicate object of this object exists. If it does not exist, the copy status information stores the value “0”. The copy state information 806 has a value "0" set as an initial value at the time when the object is first generated. When the copy object is generated by the method as described in the first embodiment, the value "1" is set. Is stored.

FIG. 6 is a processing flowchart for performing load distribution by the objects shown in FIG. The message received from another object is notified to the object processing unit 805 via the message transmitting / receiving unit 802. If the message notified from the message transmitting / receiving unit 802 can be processed, the object processing unit 805 notifies the message transmitting / receiving unit 802 that the message has been received, and at the same time, performs processing according to the content of the received message. The message transmission / reception unit 802 notifies the overload elimination detection unit 803 of the number of processing waiting messages (step 903). If the number of processing waiting messages notified from the message transmission / reception unit 802 does not exceed a predetermined number during a certain period of time measured by a counter or the like, the overload elimination detection unit 803 determines the overload state of this object. Is determined to have been eliminated (step 904), and the disappearance processing unit 804 is notified to erase the duplicate object generated by this object.

The disappearance processing unit 804 includes an overload elimination detecting unit 8
When the notification that the overload state has been canceled is received from 03 and the value “1” is stored in the copy state information (there is a copy object generated by the own object) (step 905), the message transmitting / receiving unit A deletion message for deleting the object is sent to the duplicate object via 802 (step 906), and the value “0” is stored in the duplicate status information 806 (the duplicate object generated by the own object does not exist. ), Ignore it. On the other hand, the object receives a delete message from another object (step 90).
2), the message transmitting / receiving unit 802 displays the copy status information 806.
If the value "1" is stored in (step 905), the deletion object is notified of the deletion message (step 906). On the other hand, if the copy status information 806 stores the value “0” (step 905), the message transmitting / receiving unit 802 notifies the object that is the transmission source of the deletion message that the deletion has been performed (step 908). , Notifies the free space management object and the like of a message indicating that the self object is deleted together with the information that can uniquely identify it (step 90).
9). The object that has transmitted the deletion message to the duplicate object receives the deletion confirmation message indicating that the deletion has been performed for the deletion message (step 9).
01), the value “0” stored in the replication status information 806
Then, the received deletion confirmation message is deleted (step 911).

By using the method of the third embodiment described above, with respect to the duplicate objects sequentially generated from the first object in order to eliminate the overload, the order in which the duplicate objects are generated at the time when the overload state is eliminated is opposite. Duplicate objects can be deleted in a consistent order, allowing each object to be in close proximity and keep its source continuously available, thus creating objects on reconfigurable hardware Resources can be effectively used. Further, in the method shown in the third embodiment, the overload elimination detection unit 803 can be controlled even if it is present only in the object that is initially generated, and the hardware amount of the duplicate object can be reduced.

[0024]

As described above, according to the present invention,
When there is an overloaded object that is generated independently on reconfigurable hardware and is overloaded, the load is distributed not by dividing the overloaded object but by duplicating the object. Therefore, load distribution is possible even for objects that are difficult to divide. Then, without interrupting the processing in operation for load balancing, and efficiently releasing the resources used by the object whose overloaded state has been resolved, and effectively allocating the resources of the reconfigurable hardware. You can

[Brief description of drawings]

FIG. 1 is a functional block diagram of an object showing a first embodiment of the present invention.

FIG. 2 is a processing flowchart for performing load distribution by the object shown in FIG.

FIG. 3 is a functional block diagram of an object showing a second embodiment of the present invention.

FIG. 4 is a processing flowchart for extinguishing an object whose overloaded state has been resolved in the objects shown in FIG. 3;

FIG. 5 is a functional block diagram of an object showing a third embodiment of the present invention.

FIG. 6 is a processing flowchart for performing load distribution by the objects shown in FIG. 6 is a block configuration diagram of a distribution list generation unit in FIG. 5. FIG.

FIG. 7 is a conceptual configuration diagram of PCA.

FIG. 8 is a flowchart showing the life cycle of an object.

FIG. 9 is a flowchart showing an example of solving a constraint satisfaction problem with reconfigurable hardware.

FIG. 10 is a flowchart showing an example of a conventional technique for distributing loads with reconfigurable hardware.

FIG. 11 is a diagram showing an example of message communication with an object configured on reconfigurable hardware.

[Explanation of symbols]

401, 601, 801 ... Object, 403 ... Overload detection section, 402, 602, 802 ... Message transmission / reception section, 404 ... Copy generation section, 405, 605, 805 ... Object processing section, 604, 804 ... Extinction processing section, 80
6 ... Duplication status information, 11 ... Built-in part, 12 ... Plastic part, 10 ... Cell, 31-35 ... Cell.

─────────────────────────────────────────────────── ─── Continuation of the front page (56) Reference Japanese Patent Laid-Open No. 5-233562 (JP, A) Tsunemichi Shiozawa, Reconfigurable LSI architecture that realizes general-purpose computing mechanism, IEICE technical report, IEICE Child and Information Communication Society, March 5, 1998, Vol. 97, No. 576, p. 9-16 (58) Fields surveyed (Int.Cl. ⁷ , DB name) G06F 15/177 G06F 9/46 G06F 15/80

Claims (3)

(57) [Claims] 1. A reconfigurable device that executes a series of processes by configuring a plurality of objects as a circuit on reconfigurable hardware and transferring the processing results of each object to other objects as a message. In the load balancing method in hardware, the object uses a means for detecting an overload state,
When the overload state is detected by the detection means , the unique area of the own object is set in the empty area on the reconfigurable hardware .
By sending object configuration information to generate a replication object of the own object, and transfer the newly generated the duplicated objects some or all of the message that is to wait for work own object, said replication objects A load balancing method for reconfigurable hardware, characterized in that it is executed by. 2. The load balancing method for reconfigurable hardware according to claim 1, wherein the object uses means for detecting that the overloaded state has been resolved, and the overloaded state has been resolved by the means. A load balancing method in reconfigurable hardware, characterized by deleting a duplicate object of its own object when it is detected. 3. The load balancing method for reconfigurable hardware according to claim 1, wherein an object in which the duplicate object exists detects a cancellation of an overload state or a delete message from another object. When a duplicate object exists, it sends a message to delete the duplicate object created by itself, and if the duplicate object does not exist , another object
A load balancing method in reconfigurable hardware, characterized in that, when a delete message is received from an object , the object that has sent the delete message is notified to the object that sent the delete message, and then the own object is deleted.