JPH08180025A - Scheduling device - Google Patents

Abstract

PURPOSE: To reduce overheads for holding the consistency of a cache memory and a shared memory by executing all threads belonging to the same process in the same processor. CONSTITUTION: The processors 1a-1c and the shared memory 2 are connected through a bus 3, a data group 4 no be required at the time of executing an operating system is stored in the shared memory 2, the data group 4 is provided with a data structure 5 relating to the process and further, the data structure 5 is provided with an area 6 relating to scheduling. When a certain processor processes the thread supplied to an execution queue, the processor refers to information stored in the area 6 and judges whether or not the processor itself can perform execution. In this case, when the information stored in the area 6 indicates that the execution can be performed in any processor or the information indicates the processor itself, the thread is executed.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a scheduling device suitable for use in a multiprocessor system in which a plurality of processors share a memory, and more particularly, to reduce the overhead for maintaining the consistency of cache memory and shared memory. The present invention relates to a scheduling device capable of improving system performance by making it possible.

[0002]

2. Description of the Related Art In a conventional multiprocessor system in which a plurality of processors share a memory, an operating system is created on the assumption that the shared memory is used. Usually, in order to improve processing performance,
A cache memory that can be accessed faster than the memory is provided, and the result of accessing the memory is stored in this cache memory.

However, even if the process scheduler shares the address space among a plurality of processes, the process scheduler does not consider it in the schedule, and therefore the processes sharing the address space are It may be executed by different processors, and if an update such as writing is performed in the shared address space at this time, it is necessary to perform exclusive control to maintain the coherency of the cache memory. It became an overhead and reduced the efficiency of the whole system.

[0004]

As described above, in the conventional scheduling device of a multiprocessor system in which a plurality of processors share a memory, when the processes are scheduled, the sharing of the address space between the processes is taken into consideration. Since it was not inserted, there was a problem that an overhead for maintaining the consistency of the cache memory and the shared memory was generated.

The present invention has been made in view of the above circumstances, and when an address space is shared between processes,
By scheduling and executing those processes on the same processor, the overhead for maintaining the consistency of cache memory and shared memory is reduced, and a scheduling device that can improve system performance is provided. The purpose is to

[0006]

SUMMARY OF THE INVENTION The present invention is a scheduling device for a multiprocessor system in which a plurality of processors share a memory and executes a process composed of a plurality of threads sharing an address space. In the above, a means for managing information indicating a processor in which each of the threads is to be executed in process units, and when the processor executes the threads accumulated in the execution queue It is characterized in that it has means for judging whether or not it can be executed by a processor, and all threads belonging to the same process are executed by the same processor.

Further, according to the present invention, the management means manages information indicating a processor in which each thread is to be executed in units of this process group when an address space is shared among a plurality of processes. And all threads belonging to the same process group are executed by the same processor.

Further, according to the present invention, when the management means shares the address space among a plurality of process groups, information on all the process groups formed by the process on the side requesting the address space sharing is displayed. The present invention is characterized by including means for updating the sharing of the address space to the information of the process group formed by the process on the requested side, and all threads belonging to the process group sharing the address space are executed by the same processor.

Further, according to the present invention, when the management means cancels the sharing of the address space, whether the sharing of the address space between the process groups formed by this process is canceled or not. It is characterized in that it is provided with means for allocating individual information to each of these process groups when the determination is made and sharing of the address space between the process groups is resolved. Further, the present invention is characterized in that the managed information includes information indicating that any of the plurality of processors may be executed.

[0010]

According to the structure of the present invention, the management means manages the information indicating the processor in which each thread is to be executed in process units, and when the processor executes the threads accumulated in the execution queue. By referring to this managed information, it is determined whether or not the thread is an executable thread. Specific examples that can be executed by this determination are: (1) When the information indicates that any processor may execute the information. (2) If the information indicates its own processor. Is mentioned.

Since this information is managed on a process-by-process basis, all threads belonging to the same process will be executed by the same processor, and the consistency of the cache memory and shared memory generated by sharing the address space. Can reduce the overhead for holding.

Further, according to the configuration of the present invention, when the sharing of the address space occurs among a plurality of processes, the management means described above is a process group unit formed by the plurality of processes sharing the address space. Manages information indicating which processor each thread should execute.

For example, when the processes B and C request sharing of the address space used by the process A, the processes A, B and C are treated as one process group, and information is managed in units of this process group. To do.

As a result, A, which shares the address space,
All threads belonging to the process group formed by the processes of B and C will be executed by the same processor, and the consistency of the cache memory and shared memory generated by sharing the address space between these processes will be maintained. Overhead can be reduced.

Further, according to the configuration of the present invention, when the address space is shared between a plurality of process groups, the above-mentioned management means forms all the processes formed by the process requesting the address space sharing. The process group information is updated to the process group information formed by the process on the side requested to share the address space.

For example, now, there is a first process group composed of A, B and C, and a second process group composed of X, Y and Z. The first and second process groups are present. Are to be executed by individual processors. Then, consider a case where the process X forming the second process group requests sharing of the address space used by the process A forming the first process group.

At this time, the management means determines whether or not the information of the first process group formed by the process A and the information of the second process group formed by the process X are the same and different. If so, the information of the second process group is updated to the information of the first process group.

As a result, the processes of A, B, C, X, Y and Z are all executed by the same processor, and the cache memory and the cache memory generated when the processes of A and X share the address space. The overhead of maintaining shared memory coherency can be reduced.

If the process X has formed a process group other than the second process group formed with the Y and Z processes, the information of all process groups is changed to These overheads are reduced by updating the information of one process group.

Further, according to the configuration of the present invention, when any process cancels the sharing of the address space, it is determined whether the sharing of the address space between the process groups formed by this process is canceled or not. However, when sharing of the address space between the process groups is canceled, individual information is allocated to each of these process groups.

Here, when the first process group formed by A, B and C as described above and the second process group formed by X, Y and Z share the address space, Specifically, assuming that the processes of A and X share the address space, these A and X are
Consider the case where the sharing of the address space by the process is canceled.

At this time, the management means uses the first and second
It is determined whether the sharing of the address space between the process groups is resolved. As an example of rejecting the sharing of the address space between the process groups by this determination, further B
And the processes of Y and Y share the address space.

Then, when the sharing of the address space between the process groups is resolved, there is no reason to execute it in the same processor anymore, so it is possible to allocate the information of the second process group to other information. Become. This allocation is
It may be performed according to a predetermined rule such as based on the operating rate of the processor. This makes it possible to further improve the efficiency of the entire system.

[0024]

Embodiments of the present invention will be described below with reference to the drawings. First, a first embodiment of the present invention will be described with reference to FIG. FIG. 1 is a diagram showing a schematic configuration of the scheduling device according to the first embodiment.

As shown in FIG. 1, in the scheduling apparatus according to this embodiment, the processors 1a to 1c and the shared memory 2 are connected via a bus 3. In addition, the shared memory 2 stores a data group 4 required when the operating system executes. The data group 4 includes a data structure 5 related to the process, and the data structure 5 related to the process further includes
Area 6 for storing information about scheduling
It is included. An area 6 for storing information regarding this scheduling stores the ID of the processor in which the thread belonging to each process is to be executed. If any of the processors 1a to 1c may be executed, a value indicating that is stored.

Here, when a processor attempts to process a thread put in the run queue, the processor refers to the information stored in this area 6 and determines whether or not it is executable. To judge. In this case, the information stored in the area 6 indicates that (1) it may be executed by any processor. (2) The information indicates its own processor. Sometimes that thread executes.

As a result, the information of the processor that should execute the thread is managed in process units, and the overhead for maintaining the consistency of the cache memory and the shared memory generated by sharing the address space is reduced. Can be made.

Next, a second embodiment of the present invention will be described with reference to FIGS. As shown in FIG. 2, in the scheduling device according to the embodiment, the processors 1 a to 1 c and the shared memory 2 are connected via a bus 3. Also,
The shared memory 2 stores a data group 4 required when the operating system executes. The data group 4 includes a data structure 5 regarding a process and a data structure 8 regarding sharing of an address space among a plurality of processes. Further, the data structure 5 regarding this process stores information regarding scheduling. Area 6 and a pointer 7 pointing to a data structure 8 related to sharing of the address space.

3 and 4 are conceptual diagrams specifically showing the data structure 8 relating to sharing of the address space.
Here, as shown in FIG.
Consider the case where there are a, 9b and 9c and they share an address space. As shown in FIG. 4, the data structures corresponding to these processes are 13a to 13a, respectively.
c. Then, a data structure 11 called a procgroup is assigned to this process group. In addition, pgseg data structure 1 corresponding to each process belonging to this process group
2a to 12c are assigned. And these are held in linked form.

This procgroup 11 is a pointer pg-pgseglink that points to a pgseg data structure, and a lock pg-pgs that locks it when updating it.
It is composed of eglock and a member pg-cpu in which the ID of the processor in which the process belonging to this procgroup 11 is to be executed is stored. On the other hand, pgseg 12a-12c
Is a pointer to the next pgseg structure
pgseg-link, pgseg-pg which is a pointer for pointing procgroup 11, and pgseg-procp which is a pointer for pointing the data structure 13a-13c of the process to which this pgseg belongs. In addition, in the data structure 13a to 13c of each process, the corresponding pgseg
It is a pointer for pointing the data 12a to 12c.
There is a member called p-pgsegp. This p-pgsegp stores the initial value when the address space is not shared.

The operating procedure of the operating system when the address space is shared between processes will be described with reference to FIG. FIG. 5 is a flow chart for explaining the operating procedure of the operating system when the address space is shared between processes.

First, the operating system is proc
group data structure 11 and pgseg data structures 12a-1
2c is allocated (steps A1 and A2 in FIG. 5), and the respective data structures are appropriately linked to initialize each member (step A3 in FIG. 5). Finally, the operating system determines which processor should execute these process groups, and stores the processor ID in pg-cpu, which is a member of the procgroup data structure 11 (step A4 in FIG. 5).

Next, the operation procedure when the operating system executes a thread will be described with reference to FIG.
FIG. 6 is a flowchart for explaining an operation procedure when the operating system executes a thread.

If there is a thread submitted to the run queue (Y in step B1 in FIG. 6), the operating system checks the data structure 13a-13c of the process to which the thread belongs (step B2 in FIG. 6), and the member If p-pgsegp is not the initial value (step B in FIG. 6)
2 N) of the corresponding pgseg data structure 12a-12c
The procgroup data structure 11 is obtained from pgseg-pg (step B3 in FIG. 6), and the preset processor ID is recognized by referring to the member pg-cpu (step B4 in FIG. 6).

Here, the operating system judges whether or not its own ID and its processor ID match (step B5 in FIG. 6), and if they match, execute the thread (step in FIG. 6). Y in B5), if they do not match, the same process is repeated for the next waiting thread (N in step B5 in FIG. 6).

As a result, the processes 9a and 9 shown in FIG.
b and 9c will be executed by the same processor, and the overhead for maintaining the coherency of the cache memory and the shared memory generated by sharing the address space can be reduced.

Next, a third embodiment of the present invention will be described with reference to FIGS. 7 and 8 are conceptual diagrams specifically showing the data structure 8 regarding sharing of the address space in the embodiment.

Here, as shown in FIG. 7, when there are processes 9a, 9b, 9c, 9d and 9e in the system and they share an address space, specifically,
Processes 9a, 9b, 9c and 9d have address space 10
x, processes 9d and 9e allocate address space 10y,
Consider a case where the processes 9a and 9b share the address space 10z.

As shown in FIG. 8, the data structures corresponding to these processes are 13a to 13e, respectively.
Then, data structures 11x to 11z, which are procgroups, are assigned to the respective process groups. Further, the data structures 12a1 to 12e1 of pgseg are assigned to the processes belonging to this process group. And these are held in linked form.

This procgroup 11x-11z is pgseg
Pg-pgsegli, which is a pointer to a data structure
nk, pg-pgseglock, which is a lock for performing exclusive control when updating this, and this procgroup 11x to 11z
Pg-cpu is a member in which the ID of the processor in which the process belonging to is to be executed is stored. on the other hand,
For pgseg 12a1 to 12e1, pgseg-link, which is a pointer for pointing to the next pgseg structure, and pgseg when another address space is shared in the same process
Pgseg-plin, which is a pointer for pointing to the data structure
k, pgseg-pg which is a pointer for pointing procgroups 11x to 11z, and pgseg-procp which is a pointer for pointing to the data structure 13a to 13e of the process to which this pgseg belongs. In addition, in the data structures 13a to 13e of each process, the corresponding pgse
There is a member p-pgsegp which is a pointer for pointing the g data 12a1 to 12e1. This p-pgsegp
Stores the initial value when the address space is not shared. Further, exclusive control is required when updating all these data structures, and pglock14 indicates a lock for that purpose.

The operating procedure of the operating system when the address space is shared between processes will be described with reference to FIG. FIG. 9 is a flow chart for explaining the operating procedure of the operating system when the sharing of the address space occurs between processes.

When the address space is shared for the first time, the processing is performed according to the procedure shown in FIG. Then, here, a case will be described in which a new sharing is requested for an already shared address space.

In this case, first, the pgseg data structures 12a1 to 12e1 corresponding to the process requesting the new sharing of the address space are allocated (step C in FIG. 9).
1). Then, this allocated pgseg data structure and the procgroup data structure 11x to 1 corresponding to the address space
Link with 1z and initialize members (Fig. 9).
Step C2).

Here, when processes that share different address spaces share a new address space (Y in step C3 of FIG. 9), it is necessary to match both data structures and perform grouping. is there. At this time, follow the back link (pg-forw) or front link (pg-back) of the procgroup data structure on the side that requested sharing of the address space, and see if the procgroup data structure to which the other process to be shared belongs appears (Step C in FIG. 9)
4-C6). If the other process belongs to procgroup
If a data structure appears (Y in step C6 in FIG. 9), it means that the data structure has already been grouped by sharing, so that it is not necessary to perform new processing. On the other hand, if the procgroup data structure to which the other process belongs does not appear, grouping is performed (step C7 in FIG. 9). In this case, the procgroup data structure of the requesting process and the proc of the other process
Link with the group data structure and update all pg-cpu members of the procgroup data structure to which the requesting process belongs to the pg-cpu member of the procgroup data structure to which the requesting process belongs.

As a result, the processes 9a and 9 shown in FIG.
b, 9c, 9d, and 9e will be executed by the same processor, and the overhead for maintaining the consistency of the cache memory and shared memory generated by sharing the address space can be reduced.

Next, the operating procedure of the operating system when the sharing of the address space between processes described above is canceled will be described with reference to FIG. FIG. 10 is a flowchart for explaining the operating procedure of the operating system when the sharing of the address space between processes is canceled.

Here, the process 9d is changed from the state of FIG.
Consider a case in which the sharing of the shared address 10x is canceled.
In this case, the operating system first sets the procgroup data structure 1 corresponding to the address space to be shared.
Remove the pgseg data structure 12d1 from 1x (Fig. 1
0 step D1). At this time, if the pgseg data structure also exists in another procgroup data structure, this p
Update links between gseg data structures appropriately. In this example, since the pgseg data structure 12d2 exists, the pgseg-plink of this pgseg data structure 12d2 is initialized.

Next, the link of the procgroup data structure is followed to search for the first procgroup (step D2 in FIG. 10). In this example, 11x is applicable. And for every pgseg connected here, each pgseg-
Follow plink to find a procgroup data structure with a shared relationship, and link it to the procgroup data structure pg-link
Add to In this example, pg-pgseglink is traced from the procgroup data structure 11x, and pgseg 12a1 is searched first. And this pgseg 12a1 is pgseg 12a2
Pgseg 12a2's procgroup data structure 11z, which is a procgroup data structure 11z, is linked to procgroup data structure 11x.
(Step D4 in FIG. 10). The operating system repeats this operation, and pgseg 12b1 and
When the processing for pgseg 12c1 is completed, procgrou
Follow the pg-link of the p data structure 11x to find the next procgrou
Repeat the same process for the p data structure.

At the time when all of this processing is completed, if the process group can be divided, it is connected by pg-link.
Since the procgroup group and the unconnected procgroup group are separated (Y in step D6 of FIG. 10), the unconnected procgroup group is linked by pg-forw and pg-back (step D7 of FIG. 10). Also, the connected proc
Set pg-forw and pg-back for the group group as well as initialize pg-link.

Next, pg-cpu is updated so that one of the divided groups is executed by an appropriate processor. If there is no procgroup group that is not connected by pg-link, it means that it cannot be divided.In this case, set pg-form and pg-back and set pg-l
Initialize ink. This makes it possible to further improve the efficiency of the entire system.

[0051]

As described above in detail, according to the present invention, when an address space is shared between processes, the processes are scheduled and executed by the same processor, so that the cache memory and the shared memory can be shared. It is possible to reduce the overhead for maintaining the memory consistency and improve the system performance.

Further, when there is no need for execution by the same processor, the execution processors are appropriately allocated, so that the efficiency of the entire system can be further improved.

[Brief description of drawings]

FIG. 1 is a diagram showing a schematic configuration of a scheduling device according to a first embodiment of the present invention.

FIG. 2 is a diagram showing a schematic configuration of a scheduling device according to a second embodiment of the present invention.

FIG. 3 is a conceptual diagram specifically showing a data structure regarding sharing of an address space in the second embodiment.

FIG. 4 is a conceptual diagram specifically showing a data structure regarding sharing of an address space in the second embodiment.

FIG. 5 is a flowchart for explaining an operating procedure of an operating system when sharing of an address space occurs between processes.

FIG. 6 is a flowchart for explaining an operation procedure when the operating system executes a thread.

FIG. 7 is a conceptual diagram specifically showing a data structure regarding sharing of an address space in the third embodiment.

FIG. 8 is a conceptual diagram specifically showing a data structure relating to sharing of an address space in the third embodiment.

FIG. 9 is a flowchart for explaining an operating procedure of the operating system when sharing of an address space occurs between processes.

FIG. 10 is a flowchart illustrating an operating procedure of an operating system when sharing of an address space between processes is canceled.

[Explanation of symbols]

1a to 1c ... Processor, 2 ... Shared memory, 3 ... Bus,
4 ... Data group used by operating system, 5
... data structure regarding process, 6 ... area for storing information regarding schedule, 7 ... pointer to data structure regarding sharing of address space, 8 ... data structure relating to sharing of address space.

Claims (5)

[Claims] 1. A scheduling device of a multiprocessor system in which a plurality of processors share a memory, and which executes a process composed of a plurality of threads sharing an address space, each thread is executed. A means for managing information indicating a processor to be processed in process units, and whether the thread can be executed by the processor from the stored information when the processor executes the thread accumulated in the execution queue. A scheduling device for a multiprocessor system, comprising: a means for determining whether or not the threads belong to the same process, and all threads belonging to the same process are executed by the same processor. 2. The management means comprises means for managing information indicating a processor in which each of the threads should be executed in units of this process group when an address space is shared among a plurality of processes, 2. The scheduling device for a multiprocessor system according to claim 1, wherein all threads belonging to the same process group are executed by the same processor. 3. When the address space is shared among a plurality of process groups, the management means shares the information of all process groups formed by the process on the side requesting the sharing of the address space with the shared address space. 3. The method according to claim 2, further comprising means for updating the information of a process group formed by a process on the requesting side so that all threads belonging to the process group sharing the address space are executed by the same processor. Scheduling device for multiprocessor system. 4. The management means, when any process cancels the sharing of the address space, judges whether or not the sharing of the address space between the process groups formed by this process is canceled, 4. The scheduling device for a multiprocessor system according to claim 3, further comprising means for allocating individual information to each of these process groups when sharing of the address space between the groups is canceled. 5. The multi-information according to claim 1, wherein the managed information includes information indicating that any of the plurality of processors may be executed. Processor system scheduling device.