JP6445876B2 - Resource allocation device, resource allocation system, and resource allocation method - Google Patents

Description

  The present invention relates to a technology of a resource allocation device, a resource allocation system, and a resource allocation method.

  When there are a plurality of processes that access shared resources such as shared data, data consistency may be lost due to simultaneous access or the like. Therefore, Non-Patent Document 1 describes a simultaneous access control means called exclusive lock. When an exclusive lock is placed on data for a process, other processes cannot access the data. Thereby, data consistency can be ensured by limiting the processes that can access the resource.

It should be noted that the process that puts an exclusive lock on the shared data releases the lock when the process on the shared data is finished. Thereafter, other processes can access the shared data.
Non-Patent Document 2 describes, as a side effect of using an exclusive lock, an event in which another process cannot access shared data even if the process releases the shared data lock under a specific condition.

E. W. DIJKSTRA, "Solution of a Problem in Concurrent Programming Control", Communications of the ACM, Volume 8, Number 9, Sept. 1965, p. 569 Yudai Kitano, "A Study on Processing Delay in Multi-core Environment", Proceedings of the 2013 IEICE Society Conference, B-16-3, Sep. 2013

  In order for a process to be able to process using shared data, it is necessary that the computer resources (such as a CPU) on which the process operates have a margin after successful exclusive lock for accessing the shared data. is there.

On the other hand, if there is not enough computer resources even if the exclusive lock is successful, or if another process locks the computer first even if there is enough computer resources, an extra waiting time is generated for the process. Resulting in. Therefore, even if there is a sufficient processing capacity in the entire system, when there are a plurality of processes that access the shared resource, the utilization efficiency of the system has not been sufficiently improved.
Note that if the system usage efficiency is poor, resources are idle at one location, but the load is concentrated locally at another location, resulting in fewer processing results for the entire system.

  Therefore, the main object of the present invention is to improve the use efficiency of the system when there are a plurality of processes accessing the shared resource.

In order to solve the above-described problem, the present invention groups a set of execution units that use the same shared resource with respect to execution units of a program that uses one shared resource, and can access the same shared resource. Assigning means for allocating a set of the grouped execution units together on the same computing means, and receiving the input of the execution units using a plurality of shared resources and using the shared resources to access the shared resources The execution unit of the call destination for each shared resource to be divided into the execution unit of the call source for calling the access instruction to the execution unit of the call destination, and the execution unit of the call destination is grouped And when the execution unit assigned on the first calculation means by the assigning means is moved to the second calculation means. Have a, a moving means for moving on said second operation means together a set of execution units belonging to the first operation means the same groups assigned on, the assigning unit, grouped the The execution unit of the call source that is not grouped is assigned to a computing means to which no set of execution units is assigned .

As a result, the group of execution units grouped is not executed at the same time, so that the execution unit that can access the shared resource appropriately uses the computer resources of the computing means, thereby improving the utilization efficiency of the system. Furthermore, when a failure occurs in a shared resource, the range of influence can be easily specified as the same group.
Furthermore, the efficiency of use of the system can be improved even for a complicated program that uses a plurality of shared resources.
Even when the system configuration such as physical movement of the shared resource is changed, or when the calculation means of the allocation destination is congested, it is possible to cope with the system at a low cost while improving the system utilization efficiency.

  The present invention is characterized in that the allocating unit selects an allocating destination computing unit so that the number of execution units allocated to each computing unit is equal for a plurality of computing units that are allocation candidates.

  Thereby, load distribution of each calculating means can be easily realized.

  In the present invention, the allocating unit selects an allocating destination computing unit so that the load of generating the execution unit allocated to each computing unit is equal for a plurality of computing units that are allocation candidates. And

  Thereby, load distribution of each calculation means is realizable with high precision.

  The present invention is characterized in that the assigning means selects a computing means with the lowest access cost among the computing means capable of accessing the same shared resource for a plurality of computing means that are allocation candidates.

  Thereby, it is possible to improve the throughput when executing the execution unit.

Each computing means of the present invention waits for the end of a certain execution unit to start another execution unit when executing the grouped execution unit set assigned to itself,
When the execution time of a predetermined execution unit has passed a predetermined time, the predetermined execution unit is timed out, and an abnormality is notified to the execution unit of the caller that called the predetermined execution unit .

  As a result, exclusive control between execution units within the group is performed, so that the consistency of the data content of the shared resource can be guaranteed.

  According to the present invention, when there are a plurality of processes that access a shared resource, the utilization efficiency of the system can be improved.

It is a block diagram which shows the resource allocation system regarding one Embodiment of this invention. 5 is a flowchart illustrating a resource allocation method according to an embodiment of the present invention. FIG. 3A is an explanatory diagram illustrating grouped resource allocation processing. FIG. 3B is an explanatory diagram showing problems of resource allocation processing that is not grouped. It is explanatory drawing which shows the process division | segmentation process regarding one Embodiment of this invention. FIG. 5A is a configuration diagram showing a group management table in the configuration of FIG. FIG. 5B is a configuration diagram showing a group management table in the configuration of FIG. FIG. 6A is a configuration diagram showing a group management table before allocation in the first allocation example. FIG. 6B is a configuration diagram showing the group management table after allocation in the first allocation example. FIG. 7A is a configuration diagram showing a group management table before allocation in the second allocation example. FIG. 7B is a configuration diagram showing a process weight table. FIG. 7C is a configuration diagram showing the group management table after allocation in the second allocation example. FIG. 8A is a configuration diagram showing a group management table before allocation in the third allocation example. FIG. 8B is a configuration diagram showing a VM management table. FIG. 8C is a configuration diagram showing the group management table after allocation in the third allocation example. FIG. 9A is a configuration diagram showing the movement process of the grouped processes. FIG. 9B is a configuration diagram illustrating the problem of the migration process of processes that are not grouped.

  Hereinafter, an embodiment of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a configuration diagram showing a resource allocation system.
The resource allocation system is arranged by arranging one or more physical servers 2 that provide resources and processes (or execution units of programs such as threads, tasks, and jobs) for the physical servers 2. A resource allocation device 1 that allocates resources to processes is connected to a network.
Each device of the resource allocation system is configured as a computer having a CPU (Central Processing Unit), a memory, a hard disk (storage means), and a network interface. This computer executes a program read on the memory by the CPU. Each processing unit is operated.

  1 illustrates a configuration in which one resource allocation device 1 manages (connects) two physical servers 2 collectively from the outside. On the other hand, a separate resource allocation device 1 may be built in each physical server 2, and the physical server 2 and the resource allocation device 1 may be configured as the same casing. If the same chassis is used, each unit of the resource allocation device 1 may be mounted on a host OS that manages the VM of the physical server 2.

Each physical server 2 includes one or more CPU cores (hereinafter abbreviated as “core”) and data storage means (memory, hard disk, etc.) used in processing executed by the core. A plurality of cores (multi-cores) may exist in one physical server 2.
Furthermore, the physical server 2 may construct a VM (Virtual Machine) that manages computer resources such as cores. By concealing the computer resources in the VM, the computer resources are used without making the user (user process) aware of the specific hardware configuration. This eliminates the need to specify a specific hardware configuration in the process, thereby reducing the process programming burden.

The resource allocation device 1 allocates a process to each core of the physical server 2. Here, the resource assignment device 1 may assign the process directly to the core without going through the VM, or may assign the process to the core through the VM (giving an instruction to the VM).
When issuing an instruction to the VM, it is necessary to expand the function of the VM so as to accept an instruction that clearly indicates (does not conceal) hardware resources such as “Place the process P1 in the core C1”.

  The resource allocation device 1 includes a communication unit 11, a process division unit 12, a process allocation unit 13, a process migration unit 14, a group management table 15, a process weight table 16, and a VM management table 17. Hereinafter, details of each of these components will be described with reference to FIG. 2 and FIG. 2.

FIG. 2 is a flowchart showing a resource allocation method.
S <b> 11 is a process for determining whether process division is necessary by the process division unit 12. The process dividing unit 12 determines whether it is necessary to divide each process to be allocated input to the resource allocation device 1 for each process.
First, when one process accesses (data read or data write) 0 or one shared resource (for example, shared data indicated by “data” in FIG. 1), the process does not need to be divided (S11). , No), the process proceeds to S13.
On the other hand, when one process accesses two or more shared resources, since the process needs to be divided (S11, Yes), the process proceeds to S12.

  S <b> 12 is process division processing by the process division unit 12. The process dividing unit 12 divides one pre-division process that needs to be divided in S11 into one caller process and a plurality of callee processes. For example, when the pre-division process accesses the shared data A, B, and C, the pre-division process is divided into one caller process and three callee processes (a total of four processes).

S13 is a process grouping process by the process allocation unit 13. The process allocating unit 13 groups the processes that access the same shared resource as one group for each process that does not require division in S11 and each process that is divided in S12. A process group that does not access the shared resource may not be grouped. The group management table 15 stores the grouped result of S13.
S <b> 14 is process allocation processing by the process allocation unit 13. The process allocation unit 13 instructs each core via the communication unit 11 to allocate a core for each group of S13. In other words, process groups belonging to the same group are collectively assigned to the same core. Various methods can be applied to this allocation algorithm, and the process weight table 16 and the VM management table 17 are used for determining an allocation destination by these methods (for details, refer to the description of FIGS. 6 to 8). .

  S15 is a process for determining whether or not the process movement unit 14 needs to move the process. The execution time of the allocated process may be reduced due to a reason that another high priority process is generated on the core where the process already allocated by the process allocation unit 13 is executed. In that case, the process moving unit 14 determines that the process assigned to a certain core is moved to be executed by another core (S15, Yes), and advances the process to S16. On the other hand, if it is not necessary to move the process (S15, No), the process is terminated.

S <b> 16 is a process transfer process by the process transfer unit 14. Similar to S <b> 14, the process moving unit 14 instructs each core via the communication unit 11 to move a group of processes belonging to the same group together to the same core.
In this way, in the initial allocation of processes (S14) and process migration (S16), the process group accessing the same shared data is prevented from being executed by different cores, thereby preventing access competition to the same shared data. it can.

FIG. 3A is an explanatory diagram showing the resource allocation process (S14) grouped in S13.
Processes P1 and P4 belonging to the group G1 for accessing the shared data D1 are collectively assigned to the core C1.
A process P2 belonging to the group G2 for accessing the shared data D2 is assigned to the core C2.
Processes P3 and P5 belonging to the group G3 for accessing the shared data D3 are collectively assigned to the core C3.

  Each core may perform the following exclusive control on the process group assigned to itself as a group. For example, the processes P1 and P4 belonging to the group G1 are executed in the order of the processes P1 and P4, and the process P4 is started after the execution of the process P1 is completed (that is, the processes P1 and P4 are not executed simultaneously). The execution order of each process in exclusive control is managed by, for example, a queue (queue). This exclusive control itself may be executed by an OS on the core or a user process on the core.

  Further, as an exception process of exclusive control, if the execution does not end even if the elapsed time from the execution start time of the process P1 exceeds a predetermined time (for example, 10 minutes), the process P1 is regarded as an abnormal execution state such as freeze. An abnormality notification may be sent to the calling source process that called the process P1, or the process P1 may be stopped (timed out) and the next process P4 may be executed. Thereby, exclusive control with a high degree of freedom becomes possible.

FIG. 3B is an explanatory diagram illustrating a problem of resource allocation processing that is not grouped as a comparative example. Unlike FIG. 3A, the process P1 accessing the shared data D1 and the process P4 accessing the same shared data D1 are assigned to different cores C1 and C2.
In this comparative example, the process P1 places an exclusive lock on the shared data D1, thereby prohibiting the process P4 from accessing the shared data D1. Thereafter, the process P1 releases (unlocks) the exclusive lock of the shared data D1, thereby permitting the process P4 to access the shared data D1.

  However, since the processes P1 and P4 do not make adjustments such as when to lock each other, the exclusive lock and lock waiting for the shared data D1 occur frequently, and the use efficiency of the computer resources such as the cores C1 and C2 is poor. . In addition, when a deadlock due to unlock leakage occurs, it is costly to investigate the cause such as inquiring the OS of the core C1 that manages the semaphore for the shared data D1.

FIG. 4 is an explanatory diagram showing process division processing (S12) by the process division unit 12.
Assume that the process division unit 12 determines that the process P2 is the division target (S11, Yes) among the five processes P1 to P5 in FIG. Then, it is assumed that the process P2 is processing for reading the shared data D1 and D3, calculating the sum thereof, and writing it to the shared data D2.

As shown in FIG. 4, the process dividing unit 12 divides one process P2 into four processes P21 to P24.
The process P24 is a caller process that calls other callee processes P21 to P23. The process P24 is assigned to the core C4 and does not belong to the group.
The process P21 is a call destination process that reads the shared data D1, and belongs to the group G1. The process P24 notifies a read command specifying the ID value of the shared data D1 through socket communication with the process P21.
The process P23 is a call destination process that reads the shared data D3 and belongs to the group G3. The process P24 notifies a read command specifying the ID value of the shared data D3 via socket communication with the process P23.

  The process P22 is a call destination process that writes to the shared data D2, and belongs to the group G2. The process P24 notifies a write command specifying the ID value of the shared data D2 through socket communication with the process P22. In this write command, the sum of the shared data D1 and D3, which is the calculation result by the process P24, is designated as the write data.

Here, by placing the call source process P24 outside the group in the core C4, the load on each of the call destination processes P21 to P23 can be reduced.
On the other hand, the processes P22 and P24 may be integrated (that is, the caller process and the callee process are combined as one process), and the process P22 belonging to the group G2 may calculate the sum of the shared data D1 and D3. . Thereby, the burden of process management can be reduced by reducing the number of processes after the division from four to three.

  Note that the call destination processes P21 to P23 may be provided in advance in the physical server 2 as middleware, and the API (Application Programming Interface) may be provided to the developer. As a result, the developer of the application only needs to create the caller process without being aware of the locking and unlocking of data, thereby reducing the development cost.

  FIG. 5A is a configuration diagram showing the group management table 15 in the configuration of FIG. In the group management table 15, for each group, the shared data handled by the group, the ID of the process that accesses the shared data, and the ID of the core in which the process is arranged are associated with each other.

FIG. 5B is a configuration diagram showing the group management table 15 in the configuration of FIG. As described above, the process ID “P2” in FIG. 5A is divided into the process IDs “P21 to P23” in the group and the process ID “P24” outside the group in FIG. 5B. .
Hereinafter, with respect to specific examples of creating the group management table 15 by the process allocation process (S14), the first allocation example (see FIG. 6), the second allocation example (see FIG. 7), and the third allocation example (FIG. 8). Reference) will be described in order.

  FIG. 6A is a configuration diagram showing the group management table 15 before allocation in the first allocation example. Compared to FIG. 5A, since it is not yet determined which core each process is assigned to, the “core ID” column does not exist (or is blank).

FIG. 6B is a configuration diagram showing the group management table 15 after allocation in the first allocation example.
The process allocation unit 13 measures the number of processes in the process ID column of the group management table 15 and writes the result in the rightmost column “number of processes”. Next, the process allocation unit 13 allocates the “core ID” column so that the number of processes executed in each core is equal. For example, in FIG.6 (b), it equalizes between 4-5 as follows.
(Total number of core C1 processes) = 2 (G1) +2 (G4) = 4
(Total number of core C2 processes) = 4 (G2)
(Total number of core C3 processes) = 3 (G3) +2 (G5) = 5

  FIG. 7A is a configuration diagram showing the group management table 15 before allocation in the second allocation example. The group management table 15 in FIG. 7A is the same data as that in FIG.

FIG. 7B is a configuration diagram showing the process weight table 16. The process weight table 16 is a table for specifying a weight indicating a load (a CPU usage rate, a memory usage rate, an access load to shared data, etc.) when executing at the core of the process for each process. For example, since the weight of the process P1 is 15 and the weight of the process P2 is 5, it can be seen that the process P1 applies a load almost three times that of the process P2.
Note that the weight determination method includes, for example, one of the following methods.
The load weight is statically determined by the designer.
The load weight uses the “number of execution steps” as a result of executing the process by the test code.
The load weight is determined from the CPU usage time of the process in a predetermined period and is dynamically updated.

FIG. 7C is a configuration diagram showing the group management table 15 after allocation in the second allocation example.
The process allocation unit 13 identifies the weight of each process in the process ID column of the group management table 15 from the process weight table 16 and writes the sum to the rightmost column “sum of weights”. For example, in the group G1, since the weight of P1 is 15 and the weight of P6 is 20, the sum of the weights is 35 = 15 + 20. Next, the process allocation unit 13 allocates the “core ID” column so that the sum of the weights executed in each core is equal. For example, in FIG.7 (b), it equalizes between 40-50 as follows.
(Sum of weights of core C1) = 35 (G1) +15 (G5) = 50
(Sum of weights of core C2) = 25 (G2) +15 (G4) = 40
(Sum of weights of core C3) = 45 (G3)
Then, for example, the process assigning unit 13 assigns each process belonging to the group to each core determined by equalization in ascending order of the group ID.

  FIG. 8A is a configuration diagram showing the group management table 15 before allocation in the third allocation example. The group management table 15 in FIG. 8A is the same data as that in FIG.

FIG. 8B is a configuration diagram showing the VM management table 17. The VM management table 17 includes a first table 17a indicating which VM is under the management of each shared data, and a second table 17b indicating which core is accommodated for each VM. .
For example, the shared data D1 is arranged near the VM1 (first row of the first table 17a), and the VM1 accommodates the core C1 (first row of the second table 17b). It can be seen that the core physically closest to the location of the storage means) (that is, the core having the lowest access cost such as the smallest communication delay) is the core C1.

FIG. 8C is a configuration diagram showing the group management table 15 after allocation in the third allocation example.
As described with reference to FIG. 8B, the process allocation unit 13 writes the core physically closest to the location of each shared data in the “core ID” column of the group management table 15.

FIG. 9A is a configuration diagram showing the movement process (S16) of the grouped processes. Suppose that the group G2 on the core C2 is deleted from the state of FIG. 3A, and it becomes difficult to execute the group G1 due to the occurrence of the priority process on the core C1.
The process moving unit 14 moves a process group from the core C1 to the core C2 in units of group G1. That is, the processes P1 and P4 belonging to the group G1 are moved together to the core C2. Thereby, access contention between the processes P1 and P4 accessing the shared data D1 can be prevented.
Furthermore, the process transfer unit 14 determines a process transfer destination core for each group in response to a change in the system configuration such as a change in the arrangement of the shared data D1. Therefore, the impact on the change in the system configuration can be reduced.

FIG. 9B is a configuration diagram illustrating a problem of the movement process of processes that are not grouped as a comparative example. The difference from FIG. 9A is that, due to the congestion of the core C1, the process P1 on the core C1 retreats to the core C2, but the process P4 does not retreat.
As a result, the same situation (access contention) as in FIG. 3B occurs. Further, when the arrangement of the shared data D1 is changed, the processes P1 and P4 that access the shared data D1 are scattered in each core, so that the impact of searching for them becomes large.

The resource allocation system according to the present embodiment described above is efficient in computing resources in a virtual environment where the actual core performance and the amount of memory are concealed by the VM and the use efficiency of the system decreases. This is particularly effective in terms of effective use.
In general, in a virtual environment, processes accessing various shared data operate in parallel on various cores of various VMs, and the degree of parallelism between processes increases. For this reason, there are many exclusive locks and lock waits for shared data, and the use efficiency of computer resources is poor.

Therefore, the resource allocation device 1 according to the present embodiment groups processes that access the same shared data and allocates them to the same core in units of groups (S14) or moves the allocated group to another core (S16). By doing so, access conflict between processes for shared data is avoided.
As a result, it becomes easy to execute access to shared data between processes assigned to the same core and use of core resources, and the use efficiency of computer resources can be improved. Furthermore, when a failure in exclusive control such as unlock leakage or deadlock occurs, failure analysis such as specifying a process group that accesses the shared data in which the failure has occurred becomes easy.

Further, when the process allocation unit 13 arranges the grouped process group in the same core, as described in FIG. 3A, a queue (queue) is formed in the group. Simultaneous access to data is eliminated, and lock processing for data becomes unnecessary. For this reason, there is no waiting for lock on the data, and it is possible to efficiently use hardware resources.
Further, as described in the first allocation example (see FIG. 6), the second allocation example (see FIG. 7), and the third allocation example (see FIG. 8), the process allocation unit 13 loads between groups. In order to disperse (homogenize), the arrangement to the core is performed efficiently. As a result, load imbalance in the entire system is reduced, so that excessive performance expansion of the system can be avoided.

1 Resource allocation device 2 Physical server 11 Communication unit 12 Process division unit (division means)
13 Process allocation part (allocation means)
14 Process moving part (moving means)
15 Group management table 16 Process weight table 17 VM management table

Claims (6)

For execution units of a program that uses one shared resource, the set of execution units that use the same shared resource is grouped and grouped on the same computing means in a physical server that can access the same shared resource. Assigning means for collectively assigning the set of execution units;
An execution unit of a call destination for each shared resource to be used for receiving an input of the execution unit that uses a plurality of shared resources and accessing the shared resource, and an instruction to access the execution unit of those call destinations Dividing means for grouping the execution units of the call destinations into the execution units of the call source for calling
When the execution units allocated on the first calculation unit by the allocation unit are moved onto the second calculation unit, a set of execution units belonging to the same group allocated on the first calculation unit is collected. a moving means for moving on said second computing means Te have a,
The resource allocating apparatus, wherein the allocating unit allocates the unexecuted execution unit of the call source onto a computing unit to which the grouped execution unit set is not allocated. 2. The allocation unit selects an allocation destination calculation unit so that the number of execution units allocated to each calculation unit is equal for a plurality of calculation units that are allocation candidates. Resource allocation device. The allocating unit selects an allocating destination computing unit for a plurality of computing units which are allocation candidates so that the load of generating the execution unit allocated to each computing unit is equalized. The resource allocation device according to 1. The said allocation means selects the calculation means with the lowest access cost of each calculation means which can access the said same shared resource about the several calculation means which are allocation candidates. Resource allocation device. It is comprised including the resource allocation apparatus of any one of Claim 1 thru | or 4, and the said physical server,
When each computing means of the physical server executes the set of the execution units grouped assigned to itself, it waits for the end of one execution unit and then starts another execution unit,
When the execution time of a predetermined execution unit exceeds a predetermined time, the predetermined execution unit is timed out, and an abnormality is notified to the execution unit of the caller that called the predetermined execution unit Assignment system. The resource allocation device includes an allocation unit, a division unit, and a movement unit,
The allocating unit groups a set of execution units that use the same shared resource with respect to an execution unit of a program that uses one shared resource, on the same arithmetic unit in a physical server that can access the same shared resource. Assigning a set of the grouped execution units together,
The dividing means receives an input of the execution unit that uses a plurality of shared resources, and accesses the execution unit of the call destination for each shared resource to access the shared resource, and the execution unit of those call destinations. It is divided into the caller's execution unit for calling the access instruction, and the callee's execution unit is the target of grouping.
The moving means, when moving the execution unit assigned on the first computing means by the assigning means to the second computing means, belongs to the same group assigned on the first computing means. together a set of units to move on the second computing means,
The resource allocating method according to claim 1, wherein the allocating unit allocates the unexecuted execution unit of the call source onto a computing unit to which the grouped execution unit set is not allocated.

Images