JP3349547B2 - Scheduling system - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a scheduling apparatus for scheduling object execution, which is applied to a computer system or the like in which a plurality of virtual processors processes a program described in a parallel object-oriented language in parallel or in parallel.

[0002]

2. Description of the Related Art A program described in a parallel object-oriented language includes a plurality of objects that can be processed in parallel.

The object group has various processing contents, and the response time required for each processing content is different.

Therefore, when a plurality of object groups are present at the same time, a function for executing an object group which is difficult to respond within a required response time preferentially so that its processing can be completed within the response time. Is required.

[0005] The object group is configured to have at least one or more objects.

Such an object may request processing of another object using, for example, communication means between the objects. Therefore, switching of objects frequently occurs in order to execute one object group, and such switching processing must be performed at high speed.

In order to achieve the above object, a scheduling method for setting priorities of threads for executing an object group according to the strictness of the response time of the object group has conventionally been adopted.

[0008] Here, a "thread" refers to a so-called virtual processor that has at least the contents of registers and a stack included in the processor.
Each thread shares a given program with other threads. Therefore, a plurality of threads can execute a plurality of object groups in parallel.

[0009] Since a thread is assigned a real processor according to its priority, a group of objects executed by a thread having a higher priority is executed preferentially. The following two methods are conceivable as such methods, depending on the difference in how threads are allocated to the object group.

[0010] The first method is a thread-independent method.

This method is a method of allocating a thread to each object constituting an object group. All the threads of the object group having a strict response time statically set a high priority in advance, and preferentially assign a real processor.

However, in this method, the thread is switched each time the object is switched. In addition, the thread switching process is generally performed at a low speed because all the register contents of the processor are stored in, for example, the main memory, and the register contents of another thread are read.

A second method is a thread continuous method.

In this method, one thread is assigned to one object group.

A thread for processing a program with a short response time statically sets a high priority in advance so that a processor is preferentially assigned.

When an object requests processing of another object using the communication means between the objects,
The same thread makes a so-called “function call”
Switch objects and execute the procedure for that object.

Therefore, when switching objects, it is not necessary to switch between threads, and the objects can be switched at high speed.

The thread independent method is used, for example, in the Art System (ARTS) of Carnegie Mellon University, and the thread continuous method is used, for example, in the Cloud System (Clouds).

The details are described, for example, in "Computer Software Vol. 9 No. 3 May 1992".

Of the above two methods, the object switching process can be performed at high speed.
The adoption of the thread continuous method has become mainstream.

[0021]

In the above-described thread continuation method, the entire object group is executed by one thread having a fixed priority, so that the response time of the entire object group is satisfied, The problem arises that the response times of the individual objects constituting the group are not satisfied.

In object-oriented programming, programming is performed by dividing the processing into object-by-object processing.

In addition to the response time required for the program, the response time of each object is determined by the properties of the object.

Therefore, an object group whose response time is not strict may include an object whose response time is strict.

As an object having a strict response time, for example, a screen drawing processing object can be considered. In the thread continuation method, a low-priority thread executes an object group with a low response time, so that the drawing process is interrupted by another high-priority thread, and the drawing process is interrupted (for example, in a man-machine interface). Display processing of a predetermined command on a display image, etc.)
Occurs.

In view of the above, the present invention sets the object priority in accordance with the response time of each object in the thread continuation method, and sets the thread priority to the object priority of the object being executed. Therefore, by varying, even objects in an object group whose response time is not severe,
It is an object of the present invention to provide a scheduling means for preferentially executing an object having a strict response time limit.

[0027]

To achieve the above object, the following means are conceivable.

A plurality of object groups constituting a parallel object-oriented program are divided into a plurality of virtual processors by
A scheduling system for scheduling a virtual processor in a computer system that performs parallel or parallel processing, comprising: an object priority storage unit configured to store a predetermined priority for each object constituting each of the object groups; Object priority determining means for determining the priority of the object to be executed next by the virtual processor with reference to the contents of the object priority storing means; a priority predetermined for the virtual processor; Means for determining a priority based on a predetermined relationship from the priority of the object obtained by the rank determining means, an effective priority storing means for storing the determined priority as an effective priority, Stored in the effective priority storage means Referring to effect priority, according to a predetermined rule, a means and a virtual processor managing means for determining a virtual processors to be executed next.

[0029]

The object priority storage means stores, for example, a "priority increase number" which is a value indicating how much the priority of the thread executing each object is raised.

Based on the contents stored in the object priority storage unit, the object priority determination unit determines the number of priority increases (object priority) in the object of the thread for which the effective thread priority is recalculated.

The thread management means sets, for example, a value obtained by adding the thread priority and the object priority to the effective thread priority, and determines the next thread to be executed based on the thread priority corresponding to each thread. decide.

According to the above-described configuration, even when the object group is executed by a thread having a low priority, the specific object included in the object group is executed even if the object group is executed by a thread having a low priority. In the case of a process with a strict time limit, the programmer sets a high priority in advance in the object priority storage means and stores it, thereby avoiding interruption of thread execution only during the processing of the object. Becomes possible.

Further, since the priority order can be set for each object,
Processing of the object can be performed finely.

Further, when the priority of an object does not change, thread switching and rescheduling are not required at the time of object switching. Therefore, as in the conventional thread continuation method, the switching of objects is performed at high speed.

[0035]

BRIEF DESCRIPTION OF THE DRAWINGS FIG.
This will be described in detail with reference to FIGS.

FIG. 1 is a diagram showing how a program in which threads are described in a parallel object-oriented language is executed.

FIG. 2 is a time chart showing the change of the thread priority and the state transition in FIG.

FIG. 3 shows an embodiment of the scheduling device according to the present invention.

FIG. 4 is a configuration diagram showing a configuration in which the scheduling device of FIG. 3 is realized on a computer.

FIG. 5 is a state transition diagram of a thread, and FIG.
Thread management unit 300 constituting the scheduling device
FIG. 7 is a configuration diagram of a thread information storage unit 305 disposed in the thread management unit 300. FIG. 7 is a configuration diagram of a priority order storage unit 303 disposed in a thread management unit 300 constituting the scheduling device.
FIG. 8 is a configuration diagram of an object address information storage unit 320 that configures the scheduling device. FIG. 9 is an object priority storage unit 3 that configures the scheduling device.
10 to 14 are flow charts showing the operation in the embodiment according to the present invention. Now,
In FIG. 1, a program 100 includes an object 1,
It has an object 2, an object 3, and an object 4.

Each of the objects 1 to 4 activates another object using a message communication function which has a function of communicating a message between objects prepared in advance as a library. Among the message communication functions, a message transmission function having a function of transmitting a message includes a message function “call” and a message function “send”.

"Call" is a message transmission function having a function of interrupting the execution of the transmitting object until the receiving object returns a result.

"Send" is a message transmission function having a function of causing the transmitting object to continue execution without waiting for the result of processing by the receiving object. .

A series of objects that are sequentially processed to transmit a message to a partner object using “call” is referred to as an “object group”. Also.
Objects can be executed in parallel with each other.

In the present embodiment, the object 2 and the object 3 form an object group 110, and the object 2
Start

The object 4 forms an object group 120.

The object 1 is executed immediately after the execution of the program 100 is started. The object 1 causes the object 2 and the object 4 to call and execute “send” 130 and 140, and start processing in the order of the object group 110 and the object group 120.

The object is executed by a thread.

At the start of the processing of the object group, the thread 10 is assigned to the object 1. Only when the sending object calls and executes "send", the object group including the receiving object
A new thread is assigned.

In the program 100, the thread 20 is the object group 110, and the thread 30 is the object group 1
Assigned to 20. When a new thread is assigned, the priority of the thread is set according to the time limit of the object group.

In the present embodiment, the higher the priority, the higher the priority.

Next, FIG. 5 shows a state transition diagram of a thread.

As shown in FIG. 5, the thread has an “executing state” 510, an “executable state” 520, and a “waiting state” 5
30 states are transited.

The "execution state" is a state in which a thread to which a processor is assigned is executing a procedure existing in an object.

The "executable state" is a state in which a thread in which an environment for executing an object is prepared is waiting for a processor assignment. The “standby state” is a state in which a specific event such as an event occurs, execution is temporarily suspended, and the processor is released.

At the start of program execution, all threads are in a standby state except for the thread that executes the object to be processed first.

When a thread is newly assigned to an object group by calling “call”, or when a factor that puts a thread in a waiting state is resolved, for example, a “wakeup routine that puts the waiting state in an executable state” ", The thread shifts from the standby state to the executable state (FIGS. 5, 531).

When a thread in the executable state is assigned a processor, it shifts to the execution state as indicated by 521.
When the thread in the execution state yields the processor to another thread, it becomes an executable state as indicated by 511.

When the thread in the execution state performs a process based on a “sleep routine” that relinquishes the processor for a predetermined time, or when the thread completes the process of the object group, the thread is set to 512 as shown in FIG. Return from the execution state to the standby state.

Although the present embodiment mainly considers threads as virtual processors, such virtual processors may be so-called light weight processes.

FIG. 3 shows an example of the configuration of a scheduling device according to an embodiment of the present invention.

In FIG. 3, reference numeral 310 denotes an object dispatcher for performing message communication processing of an object, management of an object, and the like; 320, an object address information storage unit for storing an address of an object in a memory; and 330, a new execution. An object priority determining unit that determines the priority of the object based on the storage content of the object priority storing unit 340;
Reference numeral 0 denotes an object priority storage unit that stores the number of increases in the priority of the thread for each object.

Reference numeral 305 denotes a thread information storage unit for storing thread information; and 301, a thread state operation management unit for storing state information and register contents in the thread information storage unit of the thread when the thread makes a state transition. , A thread priority determining unit that calculates and determines an effective thread priority from the priority of the object and the priority of the thread that executes the object; A priority storage unit 304 for storing a thread priority performs scheduling of a processor to be assigned to a thread based on the priority information in the priority storage unit 303 and the thread state information in the thread information storage unit 305, and performs a thread switching process. Is a thread dispatcher that performs

Reference numeral 300 denotes a thread management unit for managing threads, which includes the thread state operation management unit 301, thread priority determination unit 302, priority storage unit 303, thread dispatcher 304, and thread information storage unit 305. It is configured.

Reference numerals 1 and 4 denote objects constituting the program 100, reference numerals 3011 and 3041 denote internal data of the objects, and reference numerals 3012, 3013, 3042 and 3043.
Is a procedure provided by the object.

Note that the arrow of “dotted line” indicates the flow of data, and the arrow of “solid line” indicates the flow of control. Except for the thread management unit 300, the threads assigned to the object group execute without so-called context switching.

The thread management unit 300 needs to switch contexts in order to perform thread switching processing. More specifically, the thread context is stored in the thread information storage unit 305 and executed by the thread management unit 300.

The operation of the scheduling device shown in FIG. 3 will be described below.

First, the thread executes the procedure of the object 1 at the start of the program execution.

During the procedure, "cal"
When “l” and “send” are called and executed, or when the processing of the object is completed, the thread calls and executes a library of the object dispatcher.

FIG. 10 shows the object dispatcher 3
10 is a flowchart showing the operation of the tenth embodiment.

The operation of the object dispatcher 310 will now be described.

First, it is determined what processing is requested of the object dispatcher 310 (step 1001).

If the requested process is a process by a call command and a send command, it is determined whether or not a receiving object has been generated (step 1006). If not, a receiving object is generated. (Step 1002).

Thereafter, in order to check the priority of the receiving object, the object priority determining unit uses the object names of the transmitting and receiving objects and the type of communication function (either send or call) as arguments. 3
The control is shifted to 30 (step 1003).

When "call" is used, the same thread executes the transmitting object, the receiving object, the object dispatcher 310, and the object priority determining unit 330 as a series of function calls.

Therefore, the thread that has completed the processing of the receiving object returns immediately after the processing in step 1003.

At this time, if the effective thread priority has fluctuated due to the priority of the receiving object, it is necessary to restore the original thread priority.

Then, the transmission side object name and the reception side object name in step 1003 are replaced with each other as an argument, and control is transferred to the object priority determining section 330 (step 1005). In step 1001,
If the requested processing is termination of the object processing or interruption of the object processing, the thread state and the sleep request are controlled by the thread state operation management unit 301 using the thread name and the sleep request as arguments to put the thread executing the object in a standby state. Is transferred (step 1004).

In step 1002, whether or not the receiving side object exists is determined based on the contents stored in the object address information storage section 320.

Next, FIG. 8 shows an example of a configuration diagram of the object address information storage section 320.

An object name, an object procedure name 801 and an address 802 where the object is located are stored in a table.

When the object is created, the object name and the procedure name are written in the entry of the object address information storage unit 320, and the contents of the object are mapped on the memory. Also, the mapping address is written in 802.

If the object to be executed has not been generated, the object name entry does not exist in the object name entry.

FIG. 11 shows the object priority determining unit 3
30 shows the operation.

First, the object priority determining section 330
Obtains, from the object dispatcher 310, the object name and the type of communication function (whether send or call, etc.) of the transmitting object and the receiving object as arguments (step 1101).

Next, the object priority storage section 340
, The priority of the transmitting object and the receiving object is obtained (step 1102).

Next, the type of the communication function is determined (step 1103). If the communication function is “send”, the control is transferred to the thread state operation management unit 301 using the object priority and the wakeup request as arguments (step 1103). 110
5).

In step 1103, if the communication function is "call", the priorities of the transmitting object and the receiving object are compared, and it is checked whether or not there is a change in the priority of the thread (step 1104).

In step 1104, if the priority comparison results are different, the priority of the thread is changed and rescheduling is performed (the next thread to be executed is determined again). The control is transferred to the thread state operation management unit 301 with the change request of the request as an argument (step 1107).

At step 1104, if the priority of the transmitting object and the priority of the receiving object are the same, there is no need to change the priority of the thread.
The thread transfers control to the object dispatcher and starts processing from the procedure specified by the receiving object (step 1106).

FIG. 9 shows an example of the configuration of the object priority storage unit 340 used in step 1102.

The object priority storage section 340 stores the object name 901 and the priority 902 of each object.
have. Object name 901 and priority 902
Is filled in by the object dispatcher 310 when the object is created.

The contents of the priority order 902 of the object may be described by the programmer in the definition part of the object in the program.

FIG. 12 shows a thread state operation management section 301.
The operation of FIG.

First, the thread state operation management section 301
The current thread context is stored in the thread information storage unit 305 in preparation for thread switching (step 1201).

Next, it is determined what the request is to the thread state operation management unit 301 (step 1202).

In step 1202, if the request processing is the “wakeup routine processing”, the state of the thread to be woken up in the thread information storage unit 305 is changed from the standby state to the executable state (step 1202).
4).

Thereafter, it is determined whether or not the object to be executed by the wakeup thread is specified by the wakeup routine (step 1205).

The object name to be executed and the priority of the processing are specified because the wakeup thread
This is a case where a new object is assigned to the receiving object.

If an object is specified in step 1205, the address of the procedure of the object to be newly executed is written to the program counter provided in the thread area of the thread information storage unit 305 (step 1207).

Thus, when the thread is dispatched, the thread can start processing from the specified object.

The specified priority is written in the thread information storage unit 305 as a priority within the area of the thread (step 1207).

After the processing in step 1207, control is transferred to the thread priority determining unit 302 using the thread name and the priority of the object to be executed as arguments (step 1208).

If the object is not specified in step 1205, the control is transferred to the thread dispatcher (step 1206).

At step 1202, the request processing is
In the case of the eep routine processing, the state of the thread in the thread information storage unit 305 of the designated thread is set to a standby state (step 1203).

Thereafter, control is transferred to the thread dispatcher (step 1206). In step 1202,
If the request process is a process for changing the effective thread priority, the thread state in the thread information storage unit 305 of the thread in the execution state is set to the executable state (step 1209).

The change of the effective thread priority is performed by, for example,
When the priority of the thread is changed by the priority of the object by the nd and call instructions, a request is issued from the object priority determination unit 330.

After the processing of step 1209, control is transferred to the thread priority determining unit 302 using the thread name and the priority of the object to be executed as arguments (step 1).
210).

FIG. 6 shows steps 1201 and 12
03, the thread information storage unit 30 accessed in the processing in steps 1204 and 1207.
5 shows a configuration.

The contents of the thread information storage unit 305 include a thread name 601 and a register 60 which is a part of a context.
2, 603 and the like, and the thread priority 604 and the thread status 605.

FIG. 13 shows a thread priority determining unit 302.
The operation of FIG.

First, the thread priority order of the thread designated by the argument is read from the thread information storage unit 305 from the thread state operation management unit 301 (step 1301).

The priority of the object given by the argument is added from the thread state operation management unit 301 to the thread priority obtained in the processing in step 1301, and a calculation is made as an effective thread priority (step 1302).

Note that a thread dispatcher 3 to be described later is used.
The scheduling by 04 is performed based on the effective thread priority, not the thread priority.

After the processing in step 1302, the thread name and the effective thread priority are stored in the priority storage unit 30.
Record at an appropriate place in the queue provided in 3.
(Step 1303).

Finally, control is transferred to the thread dispatcher (step 1304).

FIG. 7 shows a configuration diagram of a queue configured in the priority order storage unit 303.

In the queue in the priority storage unit 303, a table storing a thread name 701 and an effective thread priority 702 is linked by a pointer 703.

The order of connection is the order of the highest priority of the effective thread. In step 1303, new tables are connected according to the height of the order.

FIG. 14 shows the thread dispatcher 304.
The operation of FIG.

First, a thread name (TRD) is obtained from the head of the queue in the priority order storage unit 303 (step 140).
1).

Next, the state (STA) of the thread (thread of thread name (TRD)) obtained in step 1401
TE) is obtained from the thread information storage unit 305 (step 1402).

Next, the state of the thread (STATE) is determined (step 1403). If the thread is in the standby state, the thread name is newly obtained from the next table in the queue in the priority order storage unit 303, and Return to step 1402
(Step 1403).

In step 1403, if the thread state is the executable state, the thread information storage unit 305
Among them, the context is recovered to the real processor from the area corresponding to the currently selected thread name, and the processing based on the thread is started (step 1405).

FIG. 4 is a diagram showing a configuration example in which the scheduling device of FIG. 3 is implemented on a computer.

In this configuration example, the computer includes a processor 410, a disk 420 as a mass storage device, and a memory 430 as a storage device, and further has a display 440 as a display device and a mouse as a locator. 450 and a keyboard as an input device are connected.

As shown in FIG. 4, the thread management unit 300, the object dispatcher 310, the object priority determination unit 330, the object address information storage unit 320, and the object priority storage unit 34 in FIG.
0 is realized by the memory in the computer 400, and the program 100 having the objects 1, 2, 3, and 4 is stored in the memory in the computer 400, and the processor 410
As a result, the program 100 is executed.

In this embodiment, one processor 410 is provided. However, a plurality of processors may be provided to perform parallel processing of threads.

FIG. 2 shows how the scheduling device according to the present invention operates on the program shown in FIG.

With reference to FIG. 2, a specific operation of the present invention will be described.

Reference numerals 211 and 212 denote changes over time of the effective thread priority of the thread 10, respectively.
3, 224, 225, 226, and 227 are threads 20
Change of the effective thread priority of the
2, 233, 234, 235, 236, and 237 indicate a time change of the effective thread priority of the thread 30.

211, 223, 224 shown by solid lines,
226, 233, and 236 indicate that the thread is in an execution state.

212, 221, 2 indicated by hatched dotted lines
27, 231, 234, and 237 indicate that the thread is in a standby state.

222, 225 and 232 shown by dotted lines,
235 indicates that the thread is in an executable state.

In the embodiment shown in FIG. 4, since there is only one processor, only one of the threads can be in the execution state at the same time.

It is assumed that the larger the effective thread priority, the higher the priority.

Object 1, object group 110,
In the object group 120, it is assumed that the time limit is strict in the order of the object 1, the object group 120, and the object group 110.

Therefore, the thread priorities of the thread 10, thread 20, and thread 30 that execute each are set to "100", "80", and "90", respectively.

As shown in FIG. 9, the object 3 is an object with a strict time limit, and its priority is "+30". The priority of the other objects is “0”.

At the start of the program, the thread 10 is executing the object 1 with the effective thread priority “100”, while the threads 20 and 30 are in a standby state.

In the object 1, the object 4
When “send” 130 is called and executed, the thread 30 becomes executable and is assigned to the object 4.

Similarly, “send” 1 for object 2
When the thread 40 is called and executed, the thread 20 becomes executable and is assigned to the object 2.

At this time, the priority of the effective thread is “80” for the thread 20 and “90” for the thread 30 as described above.
It is.

When the thread 10 enters the standby state with the end of the object 1, the thread 30 is selected by the thread dispatcher 304, and the execution of the object 4 is started.

When a sleep instruction 160, which is an instruction to interrupt the processing for a predetermined time, exists in the object 4, the thread 30 enters a standby state.

After that, the thread 20 is selected by the thread dispatcher 304, and the execution of the object 2 is started.

In the object 2, it is assumed that a call instruction for the object 3 is executed.

The priority of the object 3 is determined to be “+30” by the object priority determining unit 330, and the thread priority determining unit 3 determines that the priority of the object is “+30”.
02 sets the effective thread priority of the thread 20 to “3”.
As a result, the priority of the thread 20 becomes
It rises to "110".

Although the process of adding the priority order of the objects has been described here, it goes without saying that other operations such as subtraction may be performed.

When the time specified by the sleep instruction in the object 4 elapses, the thread 30 becomes executable. However, since the effective thread priority of the thread 20 is high while the thread 20 is executing the object 3, it is not possible to transfer the occupation right of the processor from the thread 20.

When the processing of the object 3 is completed, the effective thread priority of the thread 20 returns to “80”.

Here, the thread dispatcher 304
Performs the thread switching process, and sets the thread 30 to the execution state.

In the above embodiment, as shown in FIG. 4, scheduling in a single processor system has been described. However, in a multiprocessor system, a distributed processing system in which a plurality of computers are connected by a network, etc. When executing in parallel,
It goes without saying that the scheduling device according to the present invention can be applied.

Also, send,
Even when there is no distinction between calls or when the communication between objects is not a message communication but a function call, the present scheduling device can be applied similarly.

As shown in the above embodiment, the object group is a process whose time limit is not strict, and as a result, even if the object group is executed by a thread having a low priority, the specific group included in the thread is executed. If the object is a process that should not be interrupted, the programmer can set a higher priority in advance to be stored in the object priority storage unit 330 to avoid interruption of the process during object processing.

[0157] Also, since the priority can be set for each object,
It is possible to control the execution order in detail.

When the priority of the object does not change, it is not necessary to switch the thread or reschedule when switching the object. Therefore, as in the conventional thread continuation method, the object switching process can be performed at high speed.

Further, when describing the "procedure" which constitutes an object, it is not necessary to perform programming in consideration of what priority order the object is incorporated into. In addition, there is no need to describe the instruction for raising the priority in the user's program, and it is only necessary to provide the priority information. Therefore, the versatility of the object is improved.

[0160]

According to the present invention, if the thread that calls and executes an object has a low priority, if the processing is such that the object must not be interrupted, the priority of the object should be set high in advance. By
It is possible to avoid thread switching processing during object processing.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram showing how a thread executes a program described in a parallel object-oriented language.

FIG. 2 is a time chart showing changes in thread priorities and state transitions.

FIG. 3 is a configuration diagram of an embodiment of a scheduling device.

FIG. 4 is an example of a configuration diagram in which a scheduling device is realized on a computer.

FIG. 5 is a state transition diagram of a thread.

FIG. 6 is a configuration diagram of a thread information storage unit.

FIG. 7 is a configuration diagram of a priority order storage unit.

FIG. 8 is a configuration diagram of an object address information storage unit.

FIG. 9 is a configuration diagram of an object priority storage unit.

FIG. 10 is a flowchart showing the operation of the embodiment according to the present invention.

FIG. 11 is a flowchart showing the operation of the embodiment according to the present invention.

FIG. 12 is a flowchart showing the operation of the embodiment according to the present invention.

FIG. 13 is a flowchart showing the operation of the embodiment according to the present invention.

FIG. 14 is a flowchart showing the operation of the embodiment according to the present invention.

[Explanation of symbols]

1 object, 2 object, 3 object, 4 object, 10 thread, 20 thread, 30 thread, 100 program, 110 object group, 120 object group, 130 sen
d, 140 ... send, 150 ... call, 16 ... sleep instruction, 1
70: wakeup instruction, 211: thread state transition and priority, 212: thread state transition and priority, 221
... state transitions and priorities of threads, 222 ... state transitions and priorities of threads, 223 ... state transitions and priorities of threads, 224 ... state transitions and priorities of threads, 22
5 Thread state transitions and priorities 226 Thread state transitions and priorities 227 Thread state transitions and priorities 231 Thread state transitions and priorities 2
32: thread state transitions and priorities; 233: thread state transitions and priorities; 234: thread state transitions and priorities; 235: thread state transitions and priorities;
236: thread state transition and priority, 237: thread state transition and priority, 300: thread management unit,
Reference numeral 301: thread state operation management unit, 302: thread priority determination unit, 303: priority storage unit, 304: thread dispatcher, 305: thread information storage unit, 3
10 Object Dispatcher, 320 Object Address Information Storage Unit, 330 Object Priority Determination Unit, 340 Object Priority Storage Unit, 40
0: computer, 410: processor, 420: disk,
430: memory, 440: display, 450: mouse, 460: keyboard, 510: execution state, 520:
Executable state, 530 waiting state, 601 thread name, 602 register, 603 register, 604 priority, 605 thread state, 701 thread name,
702: priority, 801: object name, 802 ...
Address, 803 pointer, 901 object name, 902 priority

──────────────────────────────────────────────────続 き Continued on the front page (72) Inventor Shinichiro Yamaguchi 7-1-1, Omikacho, Hitachi City, Ibaraki Prefecture Within Hitachi Research Laboratory, Hitachi, Ltd. (72) Inventor Tomoaki Nakamura 5-chome, Omikacho, Hitachi City, Ibaraki Prefecture No. 1 Inside the Omika Plant, Hitachi, Ltd. (56) References JP-A-4-160639 (JP, A) JP-A-4-350728 (JP, A) JP-A-1-205344 (JP, A) 4-100156 (JP, A) JP-A-64-26234 (JP, A) Yokohiko Yokote, "Object-Oriented Distributed Operating System", Computer Software, Japan Society for Software Science, May 15, 1992, ninth Vol. 3, No. 3, p. 206-207 (58) Field surveyed (Int. Cl. ⁷ , DB name) G06F 9/46, 9/44

Claims (5)

(57) [Claims] A plurality of object groups constituting a parallel object-oriented program are stored in a plurality of virtual processors by a plurality of virtual processors.
A scheduling system for scheduling a virtual processor in a computer system that performs parallel or parallel processing, comprising: an object priority storage unit configured to store a predetermined priority for each object configuring each of the object groups; Referring to the contents of the object priority storage means,
An object priority determining means for determining the priority of an object to be executed next by the virtual processor; and a virtual processor predetermined for the virtual processor.
A service priority, from an object priority obtained object by said object priority determining means, based on the predetermined relationship, means for determining the effective priority immediately before the virtual processor to execute said object When the virtual processor refers the effective priority storage means for storing the effective priority is the determined, effective priority stored in the effective priority storage means, according to a predetermined rule, to be executed next And a virtual processor management unit for determining the scheduling. 2. A computer system in which a plurality of virtual processors execute parallel or parallel processing of a plurality of objects constituting a program created in a parallel object-oriented language, wherein a function of a receiving side object is transmitted to a transmitting side. A scheduling system that performs inter-object synchronous communication means for causing the virtual processor to which the object is assigned to execute the call and suspending the execution of the transmitting object until the receiving object returns the execution result; For each object constituting each object group, an object priority storage unit that stores a predetermined priority, and with reference to the contents of the object priority storage unit,
An object priority determining means for determining the priority of an object to be executed next by the virtual processor; and a virtual processor predetermined for the virtual processor.
A service priority, from an object priority obtained object by said object priority determining means, based on the predetermined relationship, means for determining the effective priority immediately before the virtual processor to execute said object When the virtual processor refers the effective priority storage means for storing the effective priority is the determined, effective priority stored in the effective priority storage means, according to a predetermined rule, to be executed next And a virtual processor management unit for determining the scheduling. 3. An apparatus according to claim 1 or 2, wherein the predetermined relationship, object Yu object obtained by the virtual processor priority predetermined for the virtual processor the object priority determining means <br /> A scheduling system, wherein priorities are added to determine the effective priority. 4. The scheduling system according to claim 3, wherein the predetermined rule is such that a virtual processor having the highest effective priority value is a virtual processor to be executed next. 5. The virtual processor according to claim 1, wherein the virtual processor is a thread including at least means for storing a register value of a real processor and a stack. A scheduling system.