JPH09319601A - Process control method for semaphore - Google Patents

Abstract

PROBLEM TO BE SOLVED: To prevent the deterioration of performance by reducing lock acquisition waiting time by decreasing competition caused by the lock acquisition of queue of a process link in non-use state. SOLUTION: Concerning a multiprocessor system having an OS for synchronizing processes through a semaphore, when generating a semaphore 15-2, several process links in non-use state are taken out of a queue 3 of process link in non-use state shared between plural processors 40-1 and 40-2, and linked to a queue 9-2 of process link in non-use state to be dedicated and used for the semaphore 15-2. When turning a process 20 issuing a P instruction to the semaphore 15-2 into standby by the semaphore 15-2, one process link 103 in non-use state is taken out of a queue 9-2 of process link in non-use state to be used only for the semaphore 15-2, the name of the process 20 is set to this taken-out process link 103, and this is linked through the semaphore 15-2 to a queue 4-2 of processes waiting for events.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a semaphore process control method, and more particularly to a control method suitable for a multiprocessor system having an operating system for performing process synchronization and exclusive control via a semaphore.

[0002]

2. Description of the Related Art Generally, a computer software system is realized as a group of many processes that operate almost independently of each other. However, it is necessary to communicate with each other when requesting work from another process or when a plurality of processes share a reusable resource in sequence.
Therefore, the computer provides not only basic functions related to communication between processes, but also synchronous basic commands that allow each process to use that function. One of these is the semaphore and the P and V commands that use it. is there.

FIG. 11 shows the structure of a semaphore and a segment used in a conventional process control method. The semaphore 5 is in the main memory, and as shown in FIG. 13, the semaphore counter SCT that can take a negative value and the head address P of the queue of the process waiting for an event via this semaphore 5
Includes QHP. Generally, when the initial value of the semaphore counter SCT is 0, it is used for synchronization between processes, and when it is positive, it is used for exclusive control of shared resources.

The segment 1 is also on the main memory and stores a plurality of (9 in the example of FIG. 11) process links 6 and two pointers 7 and 8. Each process link 6
Stores a process name and a link address for connecting with another process link, as shown in FIG. In the conventional process control method, each process link 6 is managed by being connected to any of the following three types of queues.

Unused process link queue shared by a plurality of processors (also called Q / PL / FLS) Process queue waiting for an event via a semaphore (also called Q / PR / S) ) Executable process queue (Q / PR / RD
Also called Y)

That is, in the initial state, all the process links 6 are unused, so that the process links 6 are managed by a queue connected in a line by their link addresses. The pointer 7 of the segment 1 points to the address. Also, when a process that waits for an event appears through a semaphore, one unused process link for that process is taken out of the queue, and the process name of that process is set in this process link. Of the semaphore 5 is pointed to by the start address PQHP of the semaphore 5. Furthermore, when the process waiting for the event in the semaphore transitions to the ready state, the process link of that process is taken out of the queue of and is connected to the queue of, and the address of the process link at the head of this queue is segmented. The pointer 8 of 1 points. Then, when the process link used by the process in the runnable state transitions to the run state and the process link used by the process becomes the unused state, the process link is returned to the queue.

In the example of FIG. 11, nine process links 6 are used.
Of these, four process links are in use, one of them is linked to the queue 4 of processes waiting for an event via the semaphore 5, and three process links are , Are connected to the queue 2 of the process in the ready state. The remaining five unused process links are linked to the queue 3 of unused process links.

FIG. 14 shows a conventional processing flow of P instruction execution for a semaphore. The P instruction has a semaphore number (semaphore name) that is an identifier that can uniquely identify the semaphore as an argument. When a P command is issued from a certain process being executed with the semaphore number of the semaphore 5 as an argument, the hardware or firmware of the processor (hereinafter, simply referred to as firmware) acquires the lock of the semaphore 5 (A-1 ), 1 is subtracted from the value of the semaphore counter SCT of the semaphore 5 (A-2), and it is checked whether the value is negative (A-3).

If the value of the semaphore counter SCT is negative, the processor firmware acquires the lock of the queue 3 of the unused process link in order to put the process that issued the P instruction in the waiting state, and waits for this. Extract one unused process link from matrix 3 (A-
4) Block the currently executing process (process that issued the P instruction), write information such as the process name of the process into the unused process link, and then semaphore 5
After connecting to the queue 4 of the process waiting for an event via the, the queue 3 of the unused process link is unlocked (A-5). Then, the semaphore 5 is unlocked (A-6), and the instruction ends. After that, the control is transferred to the dispatcher, and the process waiting for execution is taken out from the queue 2 of processes in the ready state and executed as described later.

On the other hand, when the value of the semaphore counter SCT is not negative (0 or more), the semaphore 5 is unlocked, the instruction is terminated, and the processing of the process is continued as it is (A-7).

FIG. 15 shows a conventional process flow of V instruction execution for a semaphore. The V instruction also has a semaphore number as an argument. When a V instruction is issued from a certain process being executed with the semaphore number of the semaphore 5 as an argument, the firmware of the processor acquires the lock of the semaphore 5 (B-1) and sets the value of the semaphore counter SCT of the semaphore 5 to the value. 1 is added (B-2), and it is checked whether the value is positive (B-3).

If the value of the semaphore counter SCT is positive, the semaphore 5 is unlocked, the instruction is terminated,
The processing of the process is continued as it is (B-6).

On the other hand, if the value of the semaphore counter SCT is not positive (0 or less), one process link can be extracted from the queue 4 of processes waiting for an event via the semaphore 5 and executed. The lock of the queue 2 of the process in the state is acquired, the extracted process link is connected to the queue 2 of the process in the executable state, the process related to the process link is set to the executable state, and the process in the executable state is waited. The matrix 2 is unlocked (B-4). Then, the semaphore 5 is unlocked (B-5), the instruction is terminated, and the control is transferred to the dispatcher.

FIG. 16 shows a part of the conventional processing flow when a process is transited from the queue 2 of the process in the executable state to the execution state by the dispatcher. First, the lock of the queue 2 of the process in the executable state and the queue 3 of the process link in the unused state is acquired (C-1),
After removing the process link of the process that transits to the running state from queue 2 of the process in the ready state and fetching the process information into the processor, the process link that has become the unused state is the queue of the process link in the unused state. Connect to 3 (C-2). Then, the queue 2 of the process in the executable state and the queue 3 of the process link in the unused state are unlocked (C-3).

Here, in the case of a multiprocessor system having a plurality of processors, the queue 2 of the process in the executable state, the queue 3 of the process link in the unused state and the semaphore 5 are simultaneously accessed by the plurality of processors. Therefore, when operating the process link for the process state transition, it is necessary to acquire the lock of the corresponding queue and semaphore and exclusively operate the process link as described above.

[0016]

Conventionally, the above-described method has been adopted for the process control related to the semaphore, but due to its configuration, lock acquisition is likely to cause contention, which causes performance deterioration due to lock acquisition waiting. There was a problem that it occurred. The reason is that the queue of unused process links is shared by multiple processors, so if there are many processors sharing the queue, the unused process links will be proportional to the number of processors. This is because the frequency of accessing the queue is increased, and the ratio of contention due to lock acquisition of the queue also increases, which causes performance degradation due to lock acquisition wait.

An object of the present invention is to reduce lock acquisition waiting time and prevent performance degradation by reducing contention due to lock acquisition of a queue of an unused process link.

[0018]

SUMMARY OF THE INVENTION The present invention, in a multiprocessor system having an operating system for performing process synchronization and exclusive control via a semaphore, unused unused by a plurality of processors when the semaphore is created. For the semaphore, the first step is to take out some unused process links from the state process link queue and connect them to the unused process link queue dedicated to the created semaphore. When the process that issued the P instruction is put on standby by the semaphore, one unused process link is taken out from the queue of the unused process link that is used exclusively by the semaphore, and the extracted process link Set the name of the process and wait for the event via the semaphore. Characterized in that it comprises a second step of connecting the queue process.

Further, the present invention is characterized in that, in the first step, the number of unused process links connected to the queue of unused process links exclusively used by the semaphore can be designated by software. And

Further, according to the present invention, in the first step, the identifier of the semaphore is set to each process link connected to the queue of the unused process link dedicated to the semaphore, and the second semaphore is set. In the step, if there is no unused process link in the queue of unused process links used exclusively by the semaphore, wait for an unused process link shared by multiple processors. Takes out one unused process link from the queue, sets the name of the process in the fetched process link, and connects it to the queue of the process waiting for the event via the semaphore, and A process link linked to the queue of a process waiting for an event via When making a process link in an unused state with a transition to a state, if a semaphore identifier is set for that process link, wait for an unused process link that is used exclusively by the semaphore with the set identifier It is characterized by including a third step of returning to the queue and returning to the queue of the unused process link shared by a plurality of processors when the semaphore identifier is not set.

When an unused processor link is taken out from the queue of an unused process link shared by a plurality of processors, considering that there is a possibility that a plurality of processors may acquire it at the same time, the queue Need to get a lock. However, when a semaphore is created, some unused process links are taken out of the queue of unused process links shared by multiple processors, and an unused process dedicated to that semaphore is used. If you connect to the queue of the link, access to this queue is limited to the processor that acquired the lock of the semaphore, so when you take out an unused process link from the queue, you dare to lock the queue. There is no need to do it, and contention due to lock acquisition can be reduced.

[0022]

BEST MODE FOR CARRYING OUT THE INVENTION Next, an example of an embodiment of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram showing an example of a multiprocessor system embodying the present invention. The multiprocessor system shown in the figure includes a plurality of processors 40-1, ..., 40-n operated by program control, and a main memory 45 shared by these processors. In addition, the processors 40-1 to 40-n include various queues (a queue of executable processes, a queue of unused process links, a queue of processes waiting for an event via a semaphore, A process for operating the unused process link queue used exclusively by the semaphore, a process for executing V and P instructions, and a process for which the number of process links instructed by software such as a user process is not in use The firmware has various functions such as a means to take out from the link queue and connect to an unused process link queue that is used exclusively by the semaphore, a means to create a semaphore, and a dispatcher means.

FIG. 2 shows an example of the structure of semaphores and segments used in the method of the present invention. The semaphore 15 is in the main memory 45 of FIG. 1, and as shown in FIG. 3, the semaphore counter SCT that can take a negative value and the start address P of the queue of the process waiting for an event via this semaphore 15
QHP (value 0 when there are no processes) and the start address FLQP of the queue of unused process links used exclusively by this semaphore 15 (value 0 when there are no process links) Contains.

The segment 1 is also on the main memory 45, and stores a plurality of (9 in total in the example of FIG. 2) process links 16 and two pointers 7 and 8. As shown in FIG. 4, each process link 16 includes a process name, a link address for linking other process links (value 0 when there is no link destination), and a semaphore name that uniquely identifies the semaphore. Store. In this embodiment, each process link 16 is managed by being connected to any of the following four types of queues.

Unused process link queue shared by a plurality of processors (also called Q / PL / FLS) Process queue waiting for an event via a semaphore (also called Q / PR / S) ) Executable process queue (Q / PR / RD
Also called Y) An unused process link queue that is used exclusively by the semaphore (also called Q / S / FPL)

That is, since all the process links 16 are unused in the initial state, they are managed in a queue connected by one link by their link addresses, and the process links at the head of this queue are managed. The pointer 7 of the segment 1 points to the address. And
When a semaphore is created, some unused process links are taken out of the queue of unused process links shared by multiple processors, and the unused process dedicated to the created semaphore is used. It is reconnected to the queue of the link, and the head address FLQP in the semaphore indicates the address of the process link at the head of this queue. Also, when a process that waits for an event appears via a semaphore, one process link that is unused for that process changes from the queue that is used exclusively by that semaphore to the queue that is unused. If there is no process link, it is reserved from the queue, the process name of the process is set in this process link, and the process is connected to the queue.
The address of the process link at the head of this queue is indicated by the head address PQHP of the semaphore. Furthermore, when the process waiting for an event transitions to the ready state,
The process link of the process is taken out of the queue of and is connected to the queue of, and the pointer 8 of the segment 1 points to the address of the process link at the head of the queue. Then, when the process link used by the process changes to the unused state as the process in the ready state transitions to the running state, it is returned to the queue originally connected to or.

In the example of FIG. 2, nine process links 16 are provided.
Of the (each link address is 1 to 9), three unused process links are connected to a queue 9 of unused process links used exclusively by the semaphore 15, and one unused process link is used. The process link is connected to the queue 4 of the process waiting for the event via the semaphore 15, and the three process links are connected to the queue 2 of the process in the ready state. The remaining two unused process links are linked to the queue 3 of unused process links. Note that the total number of process links 16 is nine in this example, but this is merely for convenience of description, and it goes without saying that a sufficient number is secured so that a situation in which there is no shortage will occur.

Next, the operation of this embodiment will be described.

(1) At the time of creating a semaphore When the firmware of the processors 40-1 to 40-n creates a new semaphore according to the system macro issued by the user process or the like, the firmware is designated by the software of the user process or the like. A certain number of unused process links are taken out from the unused process link queue 3 and connected to the unused process link queue 9 used exclusively by the created semaphore. That is, each unused process link extracted from the queue 3 of the unused process link is connected in one link by the link address shown in FIG. 4 (the link address in the last process link is 0),
The address of the leading link address is set in the leading address FLQP of the semaphore. Further, the semaphore name of the created semaphore is registered in the semaphore name shown in FIG. 4 of each process link. If the software does not specify the above, the unused process link is not connected to the queue 9 of the unused process link used exclusively by the semaphore. Note that a method of setting a fixed number in the hardware can be adopted in addition to specifying the number of unused process links from software.

(2) At the time of executing the P instruction FIG. 5 shows the flow of processing of the P instruction for the semaphore in this embodiment. The P instruction has a semaphore number, which is an identifier capable of uniquely identifying each semaphore, as an argument. When a P command is issued from a certain process running on a certain processor with the semaphore number of the semaphore 15 as an argument, the firmware of the processor acquires the lock of the semaphore 15 (A-11) and Semaphore counter S
One is subtracted from the CT value (A-12), and it is checked whether the value is negative (A-13).

If the value of the semaphore counter SCT is negative, the following processing is performed in order to put the process which issued the P instruction in the standby state. First, it is checked whether the value of FLQP of the semaphore 15 is 0 (A-14). If the value of FLQP is not 0, one or more process links exist in the queue 9 of the unused process link dedicatedly used by the semaphore 15. Take out one (A-18). here,
Queue 9 is a queue exclusively used by semaphore 15, and semaphore 1 must be used to proceed to step A-18.
Since it is necessary to acquire the lock of 5, the process of locking the queue 9 separately from the semaphore 15 is unnecessary. Next, the currently executing process (the process that issued the P instruction) is blocked, the process name and link address information of that process is written to the unused process link extracted in step A-18, and the semaphore 15 is set. The process is connected to the queue 4 of the process waiting for the event (A-19). Then, the semaphore 15 is unlocked (A-17), the instruction is terminated, and the control is transferred to the dispatcher.

On the other hand, if the value of FLQP of the semaphore 15 is 0, there is no process link in the queue 9 of the unused process link that is used exclusively by the semaphore 15, and therefore, as in the prior art, The lock of the queue 3 of the used process link is acquired, and one unused process link is taken out of this queue 3 (A-1
5) Block the currently executing process (process that issued the P instruction), write the process name and link address information of the process in the unused process link, and wait for an event via the semaphore 15. After connecting to the queue 4 of the existing process, the queue 3 of the unused process link is unlocked (A-16). Then, unlock the semaphore 15 (A-17),
Finish the instruction and transfer control to the dispatcher.

Further, when it is determined in step A-13 that the value of the semaphore counter SCT of the semaphore 15 is not negative (0 or more), the semaphore 15 is unlocked (A-20) and the process is continued. Continue processing.

(3) At the time of executing V instruction The flow of processing at the time of executing V instruction is the same as the conventional processing shown in FIG. That is, the semaphore number of the semaphore 15 is used as an argument from a certain process running on a certain processor as V
When the instruction is issued, the firmware of the processor acquires the lock of the semaphore 15 (B-1) and adds 1 to the value of the semaphore counter SCT of the semaphore 15 (B-
2) It is checked whether the value is positive (B-3). If the value of the semaphore counter SCT is positive, the semaphore 15 is unlocked and the processing is continued (B-).
6). On the other hand, if the value of the semaphore counter SCT is not positive (0 or less), one process link is taken out from the queue 4 of the process waiting for an event via this semaphore 15 and is in the ready state. The lock of the queue 2 of the process is acquired, the extracted process link is connected to the queue 2 of the process in the executable state, the process related to the process link is set to the executable state, and the queue 2 of the process in the executable state is acquired. Unlock (B-4). Then, the semaphore 15 is unlocked (B-5), the instruction is terminated, and the control is transferred to the dispatcher.

(4) Process of Dispatcher FIG. 6 shows a process flow when a process by the dispatcher transits from the queue 2 of the process in the ready state to the run state. When a process transitions from queue 2 of an executable process to the execution state by the dispatcher, the area of the semaphore name in the process link of the process of the process transitioning from queue 2 of the executable process to the execution state is read and the semaphore name is read. It is checked whether or not is set (C-11).

If the semaphore name is set, the process link is originally extracted from the queue 9 of the unused process link that is exclusively used by the semaphore with the semaphore name. Therefore, the lock of queue 2 of the process in the executable state and the lock of the semaphore with the above semaphore name are acquired (C-12), and the process link of the process transitioning from the queue 2 of the process of the executable state to the execution state is established. The information of the relevant process is removed and fetched into the processor, and the unused process link is connected to the queue 9 of the unused process link that is exclusively used by the semaphore (C-13). Then, the queue 2 of the executable process is unlocked and the semaphore is unlocked (C-14), and the process is executed.

On the other hand, if the semaphore name is not set, the process link is originally taken out from the queue 3 of the unused process link. Therefore, as in the conventional method, the lock of the queue 2 of the process in the executable state and the queue 3 of the process link in the unused state is acquired (C-15), and the execution state is changed from the queue 2 of the process in the executable state. The process link of the process transitioning to is removed, the information of the process is fetched into the processor, and the unused process link is connected to the queue 3 of the unused process link (C-1).
6). Then, the queue 2 of the process in the executable state and the queue 3 of the process link in the unused state are unlocked (C-17), and the process is executed.

[0039]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the operation of one embodiment of the present invention will be described in detail with reference to the drawings.

Now, as shown in FIG. 7, nine process links 100-1 having link addresses 1-9, respectively.
There is a segment 1 including 08, and the process queue 100, 101, 10 including the process names 30, 31, 32 and the semaphore name S1 is in the queue 2 of the process in the executable state.
It is assumed that 2 are connected and the unused process links 103 to 108 are connected to the queue 3 of the unused process link. Further, the target multiprocessor system includes two processors 40-1 and 40-2 and a main memory 45. In the processor 40-1, the process with the process name 20 is processed, and in the processor 40-2, the process with the process name 21 is processed. Is running. Furthermore, the process priority is 20, 21, 3
It is assumed that the number becomes lower in the order of 0, 31, 32. Also, there is one semaphore 15-1, the initial value of the semaphore counter SCT is 0, the semaphore name is S1, and three process links 100, 101, 102 were secured at the time of creation, but the process name 30, It is assumed that the process links of 31 and 32 are in use by the semaphore 15-1.

In such a situation, as shown in FIG. 8, the processor 40-
When the firmware of No. 1 creates a semaphore 15-2 (the semaphore name is S2) having 0 as the initial value of the semaphore counter SCT, the firmware has the number (for example, four) instructed by the process 20 at the time of creating the semaphore. Process links 103 to 106 are removed from the queue 3 of the unused process links, the process links 103 to 106 are connected to each other, the semaphore name S2 is stored, and the semaphore 15-2 is used exclusively. Queue 9-2 for unused process links
To connect to the start address FL of the semaphore 15-2.
The link address (4) of the first process link 103 is stored in QP.

Next, when the P instruction is issued to the semaphore 15-2 in the process 20, the firmware of the processor 40-1 operates according to the P instruction execution flow of FIG.
First, the lock of the semaphore 15-2 is acquired, and 1 is subtracted from the semaphore counter SCT. As a result, as shown in FIG. 9, the SCT value becomes -1, so that the unused process link 103 is moved from the unused process link queue 9-2 that is used exclusively by the semaphore 15-2. Semaphore 15-2 by taking out and writing the information of process 20
Is connected to the queue 4-2 of the process waiting for the event, and the link address (4) of the process link 103 is stored in the head address PQHP of the semaphore 15-2. In this way, the process 20 enters a standby state with the semaphore 15-2.

Then, the dispatcher controls the process 40 having the highest priority from the queue 2 of processes in the ready state to be executed by the processor 40-1 according to FIG. At this time, since the semaphore name stored in the process link 100 of the process 30 is S1, as shown in FIG. 10, the process link 100 of the process 30 is extracted from the queue 2 of the process in the executable state, After fetching the information of 30 into the processor 40-1, the vacant process link 100 is connected to the queue 9-1 of the unused process link which is used exclusively by the semaphore 15-1, and the semaphore 15-1 is connected. The link address (1) of the process link 100 is written to the leading address FLQP of the.

[0044]

As described above, according to the present invention, when a semaphore is created, some unused process links are extracted from the queue of unused process links shared by a plurality of processors. The process link used to hold the process that issued the P instruction to the semaphore by connecting it to the queue of the unused process link that is used exclusively by the generated semaphore. Since it was taken out from the queue of the unused process link dedicated to the semaphore,
Compared to the conventional method that always takes out the process link from the unused process link queue shared by multiple processors, contention due to lock acquisition of the queue is reduced, lock acquisition wait time is reduced, and performance is improved. Can be improved.

Since the number of unused process links dedicated to the semaphore can be specified by software,
Efficient operation becomes possible. The reason is that the software, such as the user process that instructed the creation of the semaphore, has the best grasp of how many process links are needed, so a sufficient number of unused process links are secured. Because you can.

Further, when the unused process link dedicated to the semaphore is not created, or when it is exhausted, the unused process shared by a plurality of processors as in the conventional case. Since an unused process link is automatically acquired from the link queue,
Even if the number of unused process links specified by the software when creating a semaphore is too small, or in the operating environment of an old version of the process that does not specify such a process link, process control can be performed without any problems. it can.

[Brief description of drawings]

FIG. 1 is a block diagram illustrating an example of a multiprocessor system that implements the present invention.

FIG. 2 is a diagram showing a configuration example of a semaphore and a segment used in the present invention.

FIG. 3 is a diagram showing a configuration example of a semaphore used in the present invention.

FIG. 4 is a diagram showing a configuration example of a process link used in the present invention.

FIG. 5 is a flowchart showing an example of P instruction execution processing in the present invention.

FIG. 6 is a flowchart showing a processing example of a dispatcher according to the present invention.

FIG. 7 is a diagram showing a state of a multiprocessor system, a segment, and a semaphore used for explaining the operation of an embodiment of the present invention at a certain time.

8 is a diagram showing a state of each unit when a new semaphore is generated in the state of FIG. 7.

9 is a diagram showing a state of each part at the time when the process that issued the P instruction in the state of FIG. 8 is in a standby state.

FIG. 10 shows the state of each part at the time when the unused process link is returned to the queue of the unused process link that is used exclusively by the semaphore because the process is in the running state in the state of FIG. FIG.

FIG. 11 is a configuration diagram of a semaphore and a segment used in the related art.

FIG. 12 is a block diagram of a process link used in the prior art.

FIG. 13 is a configuration diagram of a semaphore used in the related art.

FIG. 14 is a flowchart of a P instruction execution process in the related art.

FIG. 15 is a flowchart of a V instruction execution process in the related art.

FIG. 16 is a flowchart of processing of a dispatcher according to the conventional technique.

[Explanation of symbols]

1 ... Segment 2 ... Queue of process in ready state (Q / PR / R
DY) 3 ... Unused process link queue (Q / PL
/ FLS) 4 ... Process queue waiting for an event via a semaphore (Q / PR / S) 5,15 ... Semaphore 6,16 ... Process link 7 ... Unused process link queue head Pointer that points to process link 8 ... Pointer that points to the first process link in the queue of the process that is in the runnable state 9 ... Queue for the unused process link that is used exclusively by the semaphore (Q / S / FPL)

Claims (3)

[Claims] 1. In a multiprocessor system having an operating system for performing process synchronization and exclusive control via a semaphore, an unused process link queue shared by a plurality of processors when a semaphore is created. The first step of extracting some unused process links and connecting them to the queue of unused process links to be used exclusively by the generated semaphore, and the process that issued the P instruction to the semaphore To put a semaphore into a standby state, take out one unused process link from the queue of unused process links that is used exclusively by that semaphore, set the name of the process to this extracted process link, Connect to the queue of the process waiting for an event via the semaphore Process control method for a semaphore which comprises a second step. 2. In the first step, the number of unused process links connected to a queue of unused process links exclusively used by a semaphore can be designated by software. A process control method for a semaphore according to item 1. 3. In the first step, an identifier of the semaphore is set to each process link connected to a queue of unused process links exclusively used by the semaphore, and in the second step, If there is no unused process link in the queue of the unused process link used exclusively by the semaphore, the unused process link queue shared by multiple processors is not Takes out one process link that is in use, sets the name of the process to this fetched process link, connects it to the queue of the process waiting for the event via the semaphore, and via the semaphore Transition of the process link connected to the queue of the process waiting for an event to the execution state of that process Therefore, when making a process link in an unused state, if a semaphore identifier is set for that process link, it is returned to the queue of the unused process link used exclusively by the semaphore with the set identifier, and the semaphore 3. The process control method for a semaphore according to claim 2, further comprising a third step of returning to the queue of an unused process link shared by a plurality of processors when the identifier of is not set.