JPH04343143A - Shared resource mutual exclusion method for multiprocessor system - Google Patents

Abstract

PURPOSE:To realize the efficient mutual exclusion system of shared resource, in a multiprocessor system in which parallel programs consisting of plural processes are simultneously executed by plural processors. CONSTITUTION:A confusing part 105 within a main storge 3 is the object of mutual exclusion. An inlet operation 106 and an outlet operation 107 are the programs which execute mutual exclusion to the confusing part 105. As mutual exclusion system, both a spin lock type in which a process failed in acquiring the execution right of the confusing part 105 abandons the using right of the processor and is brought into a waiting state and a semaphore type in which the process failed in acquiring the execution right of the confusing part 105 repeats the acquisition of the execution right while securing the utilization right of the processor, are used. The inlet operation 106 changes over the process which is brought into the waiting state for the acquisition of the execution right of the confusing part 105 to the spin lock type or semaphore type corresponding to the execution state of the process currently having the execution right of the confusing part 105.

Description

[Detailed description of the invention]

0001

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an efficient mutual exclusion scheme for shared resources in a multiprocessor system.

0002

2. Description of the Related Art Mutual exclusion methods for shared resources in multiprocessor systems are generally classified into spinlock methods and binary semaphore methods, and conventionally, users have selected and used either of them. The spinlock method and binary semaphore method will be explained below.

Spinlock Method FIG. 9 shows an example of the configuration of a system that performs mutual exclusion using the spinlock method. In the figure, processors 1 and 2
and main storage device 3 are connected to one system bus 4. Each of the processors 1 and 2 is capable of reading and writing any data stored in the main storage device 3 and executing any program. In the main storage device 3,
key 901, sensitive part 902, lock operation 903,
Each piece of information regarding the unlock operation 904 is stored. Here, the critical portion 902 is a program in which only one process can be executed at a time, and is subject to mutual exclusion. The value of the key 901 is 1 or 0, and the critical part 902
Indicates whether or not a process exists that has execution rights for (here, 1 indicates existence and 0 indicates empty). The lock operation 903 and unlock operation 904 are the critical parts 9
This is a program that performs mutual exclusion for 02.

FIG. 10 shows a lock operation 903 and an unlo operation.
This is an operation procedure for mutual exclusion using the ck operation 904, and when a certain process accesses the critical part 902, it first accesses the critical part 902 by the lock operation 903.
Obtained execution rights and started using the critical part 902,
When this is completed, the execution right is released by an unlock operation 904. This allows only one process to execute the critical portion 902 if multiple processes execute the lock operation 903 at the same time. Until this process performs the unlock 904 operation, other processes will idle and wait without entering the critical portion 902.

FIG. 11 is a functional block diagram of lock operation. The lock operation function is constituted by a locking means 1100. As a result of executing the locking means 1100, "dangerous part"
The process that has obtained the execution right for the "critical part" ends the lock operation (lock success), and the process that has not obtained the execution right for the "critical part" repeatedly executes the process of the locking means 1100 (lock failure).

FIG. 12 is an example of a processing flow of a lock operation.
The part surrounded by the broken line is the locking means 1100. loc
The k operation is performed in the following steps. First, the key (901 in Figure 9)
) is read out, and the value of the read key is set as x (step 1201). Next, the key is set to 1, that is, the "critical part" is locked so that it cannot be used by other processes (step 1202). Here, reading and writing to the key is performed by basic operations such as a test-and-set instruction in which reading and writing from memory are not subdivided. That is, steps 1201 and 1202 are actually implemented with one instruction. Next, the key value x read out in step 1201 is determined (step 1203). If x=0 (the critical part is unused), the lock operation is terminated (successful locking), and if x=1 (the critical part is in use), the process returns to step 1201 and the lock operation is completed. Repeat operation (lock failure). In this lock failure, the key has 1
is simply overwritten.

FIG. 13 shows the processing of the unlock operation. When a process finishes executing the "tight part", the unlock operation writes a zero to the key. When this unlock operation writes 0 to the key, the process that was idling due to the lock operation reads 0 as the key value, allowing the lock operation to end and the process to enter the "critical part".

Binary Semaphore Method FIG. 14 shows an example of the configuration of a system that performs mutual exclusion using the binary semaphore method. Processors 1 and 2 and main memory 3 are connected to one system bus 4. Each of the processors 1 and 2 is capable of reading and writing arbitrary data stored in the main storage device 3 and executing arbitrary programs. The main storage device 3 includes a critical part 1401, a semaphore s 1402, a waiting process queue 1403 for semaphore s, and a processor waiting process queue 140.
4, P operation 1405, V operation 1406, and process switching program 1407 are stored. Dangerous part 14
01 is a program that can only execute one process at a time, and is subject to mutual exclusion. The semaphore s 1404 takes 0 or 1, indicating that the critical portion 1401 is in use or vacant, respectively. The semaphore s waiting process queue 1403 is OS control data in which processes waiting for the critical portion 1401 to be used are lined up. The processor queue 1404 is OS control data in which processes that can be executed immediately upon allocation of a processor are lined up. The P operation 1405 and the V operation 1406 are programs that mutually exclude the critical portion 1401.

FIG. 15 shows P operation 1405 and V operation 1406.
This is an operation procedure for mutual exclusion using .When a process accesses the critical part 1401, it first executes the P operation 1405, and if the critical part 1401 is vacant, it accesses the critical part 1401, and the process ends. This indicates that V operation 1406 is to be executed. As a result, if multiple processes execute the P operation 1405 at the same time, only one process can perform the critical part 14
01 can be executed. And this process is V operation 14
Until 06 is executed, other processes are made to wait in the waiting process queue 1405 of semaphore s.

FIG. 16 is a functional block diagram of the P operation. The P operation function is composed of a locking means 1601 and a process execution control means 1603. As a result of executing the locking means 1601, the process that has obtained the right to execute the "critical part" ends the P operation. A process that has not been able to obtain the right to execute the "critical part" moves to the processing of the process execution control means 1602, waits in a semaphore wait state (blocked state), and waits in a semaphore wait state (blocked state),
If you are released from the semaphore wait state by an operation, "
Obtain the right to execute the "dangerous part" and complete the P operation.

FIG. 17 shows an example of the processing flow of the P operation, and the portion surrounded by broken lines is the processing of the locking means 1601 and the process execution control means 1602. The P operation is performed in the following steps. First, semaphore s (1402 in FIG. 14) is read (step 1701). Next, the value of the read semaphore s is determined (step 1702), and s=1
If the critical part is unused, the value of s is reduced by 1 to 0 (in use) (step 1703), and the P operation is terminated (lock success). Here, reading and writing to semaphore s are visible to the process as basic operations that are not thinned. On the other hand, if s = 0 (the critical part is in use) (lock failure), this P
Processes currently performing operations are placed in the semaphore waiting process queue (
1403 in FIG. 14) at the end of (step 17
04), process switching program (140 in FIG.
7) (step 1705), and the P operation is ended.

FIG. 18 is an example of the processing flow of V operation. When a process finishes using the "tight part", V
In the operation, it is checked whether the semaphore waiting process queue 1403 is empty (step 1801), and if it is empty, the semaphore s140
2 is written as 1 (step 1802), and the V operation is completed. In addition, if the semaphore waiting process queue 1403 is not empty, the first process is taken out from this semaphore queue, and the processor waiting process queue 1403 is
(step 1803), and the V operation is completed. After an appropriate amount of time has passed, process switching program 1
407 is executed, processor waiting process matrix 1
The process is taken out from 404, and the process is restarted from the point at which the process execution control means 1602 of the P operation ends.
Execute the “dangerous part.”

[0013]

[Problem to be solved by the invention] In the spin lock method, if the "critical part" is in use, the process idles, checks the state of the key, and waits until the key becomes 0.
Regarding the "tight parts" of the program, a. It must be a short program; b. Do not perform operations such as input/output that result in a wait state.c. Restrictions are imposed such that the exception handling program cannot take over the processor due to an error. Because of these restrictions, the spinlock method is generally used for mutual exclusion of limited programs such as the kernel of an OS, and has the disadvantage that it is not suitable for normal user programs.

[0014] When the spinlock method is used in a user program, the following problem occurs. (1) Due to a bug, it is possible to create a situation where execution rights for "sensitive parts" are held for a long time. (2) The lock operation does not have the function of detecting a change in the state of the process that owns the execution right for the "sensitive part". Therefore, when a process that has the right to execute a "critical part" enters a wait state or when the processor is taken away, the processor that executes the process that continues to idle will continue to idle and waste a lot of time. spend a lot of time. (3) A simple mistake in how to use the lock operation can easily lead to a deadlock. but,
The lock operation does not have the ability to check which process has the execution rights for the "sensitive part", so
It is impossible to detect a waiting state and perform appropriate processing even though the right to execute the "critical part" can never be obtained due to a simple program error.

[0015] In the binary semaphore method, when multiple processes try to execute the same "critical part", P
Since the following operation is performed for all processes that could not be decremented by 1 in the operation, there is a drawback that process switching occurs frequently in mutual exclusion.

(1) semaphore the process every time P operation
The process is placed in the waiting process queue and the process is switched. (2) Every time a V operation is performed, a process is moved from the semaphore s waiting process queue to the processor allocation waiting process queue. After the V operation, a process switch occurs.

The amount of processing required for the above operation is extremely large compared to the amount of processing required for mutual exclusion in the spinlock method.
Moreover, since the above operation is essential when a process that already has the right to execute the "critical part" exists, it has the disadvantage that it appears as a large overhead in the processing of the process. In particular, the binary semaphore method has the disadvantage that in systems where processes with a small amount of processing frequently execute "critical parts", the overhead for mutual exclusion becomes extremely large in the processing of the entire process. In addition, since the P operation does not have a function to read the state of the process that owns the execution right of the "critical part," errors such as deadlocks that occur due to the ownership relationship of the execution right can be detected and appropriate processing can be performed. There is a drawback that there is no

When executing a user program that performs mutual exclusion, the user selects and uses either the spinlock method or the binary semaphore method. At this time, the user needs to understand the shortcomings of each method and consider the operation of the process that executes the "critical part" before making a decision. Furthermore, even if the user carefully considers the mutual exclusion method and selects the mutual exclusion method, the spinlock method cannot prevent a process that executes a "critical part" from having the processor taken over by the OS. Therefore, it is impossible to avoid the drawback that a process that waits idly to obtain the right to execute a "critical part" continues to idle and consume processor power. Furthermore, the binary semaphore method cannot avoid the disadvantage that the overhead of process switching increases when executing user programs that frequently perform mutual exclusion.

An object of the present invention is that when a spinlock method is used for mutual exclusion in a user program, the process executing the "critical part" is deprived of the processor, so the process idles and loses the right to execute the "critical part". In addition, when using the binary semaphore method, if mutual exclusion occurs frequently, the overhead required for process switching will take up a large proportion of the overall process processing. This solves the problem of large size, the user having to consider whether to use both methods, or the inability to detect errors in mutual exclusion and handle exceptions. The object of the present invention is to provide an efficient shared resource mutual exclusion method in a system that executes "parts".

[0020]

[Means for Solving the Problems] The present invention provides a function for executing a parallel program consisting of a plurality of processes that can operate simultaneously on different processors, a function for each process to access a shared resource located in main memory, In a multiprocessor system that has a function to mutually exclude the right to start execution (called an execution right) of a part that can only be used by one process at a time (called a critical part),
Lock means, lock switching means, having the following functions:
A process execution state monitoring means and a process execution control means are provided.

[0021] The locking means has a function of reading and writing inseparably from a lock variable indicating whether or not there is a process that has the right to execute the "critical part";
It has a function to record the process identifier that has the right to execute the "sensitive part", and if one or more processes try to obtain the execution right to the "sensitive part" at the same time, only one process will be able to execute the "sensitive part". The identifier of the process that gained execution rights for the "sensitive part" is recorded.

The lock switching means has a function of checking whether the current mutual exclusion method is a spin lock method or a binary semaphore method, and a function of detecting an error in the program of the process that performs mutual exclusion. By the method of “
Change the waiting method of a process that waits to obtain the right to execute a "critical part," or have the process that caused the error perform exception handling.

The process execution state monitoring means has a function of mapping a process control block (called a PCB), which is control data of the OS, into the process address space, a function of reading the process state field of the mapped PCB, and a function of reading the process state field of the mapped PCB. It has a function that changes the mutual exclusion method to the spin lock method or the binary semaphore method, and allows the process waiting to obtain the execution right for the "critical part" to check the execution state of the process that has the execution right for the "critical part". Monitor the system and change the waiting method according to the results.

The process execution control means has a function of placing a process waiting to obtain the right to execute a "critical part" into a processor wait state, and a function of placing the process in a semaphore wait state and a function of executing a process switching program, and changing the process state. Depending on the result of the monitoring means, the execution state of the process waiting to obtain the right to execute the "critical part" is changed to a processor wait state or a semaphore wait state.

[0025]

[Operation] In the present invention, the mutual exclusion method is selectively changed to the spin lock method or the binary semaphore method according to the execution state of the process that has the execution right of the "critical part", and the execution right of the "critical part" is changed. Control the execution of a process that waits for a . Additionally, an error in the program of a process that performs mutual exclusion is detected and exception handling is performed. As a result, user processes, etc. are frequently
, mutual exclusion can be performed efficiently.

[0026]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 is a system configuration diagram of an embodiment of the present invention. In the figure, processors 1 and 2 and main memory 3 are connected to one system bus 4. Each of the processors 1 and 2 is capable of reading and writing arbitrary data stored in the main storage device 3 and executing arbitrary programs. The main storage device 3 includes a process control block 101, a process queue 102 waiting for a processor, a process queue 103 waiting for a semaphore, a key 104, and a critical part 1.
05, an entrance operation 106, an exit operation 107, an exception handling program 108, and a process switching program 109 are stored.

The process control block (hereinafter referred to as PCB) 101 is control data created for each process by the OS, in which the execution status of the process, the allocation status of resources to the process, etc. are written, and it is not directly accessible from the user process. It is protected against writing and reading. There is a process status field in the PCB, which indicates whether the process is running, waiting for a processor, or blocking, such as waiting for an event. In FIG. 1, PCBs of processes A and B are shown as an example, and processes A and B are each processor 1.
, 2 and is being executed.

The processor waiting process matrix 102 stores P of processes that can be executed immediately after a processor is allocated.
This is OS control data in which CBs are arranged. The semaphore waiting process queue 103 is OS control data in which processes waiting for the critical portion 105 to be used are lined up.

The key 104 consists of a PCB address, a lock variable, and a lock type variable. The PCB address contains the PCB of the process that owns the execution right for the sensitive part 105.
The first address or 0 is stored. The lock variable indicates whether there is a process that owns the execution right for the sensitive part 105 (1 means it exists, 0 means it does not exist). The lock type variable indicates whether the current mutual exclusion method is a spinlock method or a semaphore method.

[0030] The critical part 105 is a program that can only execute one process at a time.
Subject to mutual exclusion. Entry operation 106 and exit operation 10
7 is a program that performs mutual exclusion for the critical portion 105. The exception handling program 108 is a program that processes errors related to mutual exclusion, and the process switching program 109 is a program that allocates processors 1 and 2 to processes.

FIG. 2 illustrates an operating procedure for mutual exclusion of process critical portions 105 using inlet operation 106 and outlet operation 107. In other words, when a process accesses a "sensitive part", it first performs an entry operation, and if the "sensitive part" is not in use by another process, it gains execution rights to the "sensitive part" and accesses the "sensitive part". ” and when it finishes, performs the exit operation. This allows only one process to perform the "critical part" if multiple processes perform entry operations at the same time. No other process can enter the "critical part" until this process performs the exit operation.

FIG. 3 is a functional block diagram of the entrance operation. The entrance operation function is comprised of a locking means 301, a lock switching means 302, a process execution state monitoring means 303, and a process execution control means 304. As shown in Fig. 3, in the entrance operation, the spin lock method in Fig. 11,
Compared to the binary semaphore method, the lock switching means 302
and process execution state monitoring means 303 are added. Furthermore, as will be described later, the locking means 301 and the process execution control means 304 are also functionally expanded.

Next, the processing of each means of entrance operation will be explained in detail using FIGS. 4 to 7. As shown in FIG.
It is assumed that the initial values of the PCB address and the lock variable of No. 5 are 0, the initial value of the lock type variable is the spin lock type, and the process that executes the entry operation is process A.

FIG. 4 is an example of the processing flow of the locking means 301. The part surrounded by thick lines is the operation procedure newly added in the present invention to the conventional spin lock method and binary semaphore method. (1) Process A reads the PCB address of the key (step 401). Let the read value be a. Next, the value of a is determined (step 402). If a is 0 (initial value), there is a possibility that there is no process that has the right to execute the "critical part", so go to (2). In other cases, it means that there is a process that owns the execution right for the "critical part", so the processing moves to the lock switching means 302. (2) If a is 0, read the lock variable of the key (step 403). Let the read value be x. Next, the lock variable of the key is set to 1 (step 404). Here, reading and writing to the lock variable is done by test-and-
This is performed by an atomic operation using a set instruction or the like. Next, the value x of the read lock variable is determined (step 405). If x is 0, it means that process A has obtained the right to execute the "critical part", so
Go to (3). If x is not 0, go to (1). These operations are the same as those in the spinlock method and binary semaphore method. (3) If the value x of the read lock variable of the key is 0, the start address of the PCB of process A (self-process) is written to the PCB address of the key, and the entry operation is completed (step 406).

FIG. 5 shows an example of the processing flow of the lock switching means 302. The lock switching means 302 is a means not found in the conventional spin lock method and binary semaphore method, and is added according to the present invention. The entrance of the lock switching means 302 is step 402 (n
0 side), that is, process A
This is a case where the locking means 301 cannot obtain the right to execute the "critical part". (1) PCB of the key read out by the locking means 301
It is determined whether the address value a is the start address of the PCB of process A (self-process) (step 501). In the case of the first address, it means that there is an error in the program of process A and that the right to execute the "critical part" cannot be newly obtained. Therefore, in order to handle the exception, the processing of the process execution control means 304, which will be described later, is performed. Move to. In other cases, go to the next step (2). (2) Read the value of the lock type variable of the key (step 50
2). Let the read value be c. Next, the value c of this lock type variable is determined (step 503). If c indicates that the current mutual exclusion method is the binary semaphore method, process A waits for the execution right of the "critical part" to be released in the state of a semaphore waiting process. , so it goes to the process execution control means 304. In other cases, the process goes to the process execution state monitoring means 303.

FIG. 6 shows the process execution status monitoring means 303
This is an example of the processing flow. Process execution state monitoring means 30
3 is also a means not found in the conventional spin lock method and binary semaphore method, and is added by the present invention. The process execution state monitoring means 303 enters when control is transferred from step 503 (no side) in FIG. is the case of the spinlock method. (1) Determine whether the PCB whose start address is the value a of the PCB address of the key read by the locking means 301 is mapped in the address space of process A (self-process) (step 601), and check if the PCB has already been mapped. If so, go to (2). If not mapped, after mapping the PCB whose first address is a into the address space of process A (step 602),
Go to 2). Mapping here means using an accessible file as part of the address space of a process, and is achieved by using a mapping function of a general-purpose OS such as mmap of UNIX. In the case of UNIX, since the kernel data area including the PCB is provided in the form of a file, the PCB can be accessed by mapping this. (2) Read the process status field from the PCB whose starting address is the value a mapped in the address space of process A (step 603). Let the read value be s. Next, the state of this s is determined (steps 604, 605). If the value of s indicates that the process having the right to execute the "critical part" is being executed (YES in step 604), the process goes to the process execution control means 304. If the value of s indicates that the process that has the right to execute the "critical part" is not being executed but is in the processor waiting process queue (YES in step 605), the process execution control means 304 Go to processing. Otherwise, i.e. “
If the value of s indicates that the process that has the execution right for the "critical part" is in a blocked state, such as waiting for an event (no in step 605), after setting the lock type variable of the key to the semaphore method ( Step 606), the process goes to the process execution control means 304.

FIG. 7 is an example of a processing flow of the process execution control means 304. The entrance to the process execution control means 304 is activated when the lock switching means 302 detects an error in mutual exclusion (yes in step 501 of FIG.
side), when the mutual exclusion method detects the binary semaphore method (yes side of step 503 in FIG. 5), and in the process execution state monitoring means 303, "critical part"
When it is detected that the process with the execution right for the "critical part" is in a blocked state and the lock variable is changed from the spin lock method to the binary semaphore method (step 606 in FIG. 6), the process that has the execution right for the "critical part" If it is detected that the processor is in a waiting state (step 60 in FIG.
5), and when it is detected that a process that has the right to execute the "critical part" is being executed (step 604 in FIG. 6, yes). In FIG. 7, the part surrounded by thick lines is the operation newly added in the present invention to the conventional binary semaphore method. (1) When control is transferred from step 501 (yes side) in FIG. 5, that is, when the lock switching means 302 detects an error in mutual exclusion, control is transferred to the exception handling program (step 701). , exit the entry operation. (2) When control is transferred from step 503 (yes side) in FIG. 5, that is, when the mutual exclusion method is a binary semaphore method in the lock switching means 302, and when control is transferred from step 606 in FIG. When control is transferred, that is, when the process execution status monitoring unit 303 detects that the process that has the execution right for the "critical part" is in a blocked state and changes to the semaphore method, the conventional binary Using a waiting method similar to the semaphore method, in order to wait for the execution right of the "critical part" to be released, the binary semaphore function of a general-purpose OS is used to put the PCB of process A (its own process) into a semaphore state. It is added to the end of the process matrix (step 702). and,(
Go to 4). (3) When control is transferred from step 605 (yes side) in FIG. 6, that is, the process execution state monitoring means 30
In step 3, if it is detected that the process that has the right to execute the "critical part" is waiting for the processor, the process that has the right to execute the "critical part" has been deprived of the processor and has stopped. This means that a processor allocated to a process that waits to get the right to execute a "critical part" is wasted time.
In order to release the processor allocated to the own process, the process control function of the general-purpose OS is used to place the PCB of process A at the end of the process queue waiting for the processor (step 703), and the process goes to (4). (4) Execute the process switching program and pass the processor assigned to the own process to another process (
Step 704). After a while, when a processor is assigned to this process (process A) again,
To perform the entrance operation, go to the locking means 301 again (
Control is transferred to step 401 in FIG. 4). This operation is the same as the conventional binary semaphore method. (5) When control is transferred from step 604 (yes side) in FIG. 6, that is, the process execution state monitoring means 30
In step 3, if it is detected that a process that has the right to execute the "sensitive part" is running, the right to execute the "sensitive part" may be released within a relatively short period of time. In order to acquire the execution right for the "critical part", go to the locking means 301 again (step 4 in FIG. 4).
01).

FIG. 8 is an example of the processing flow of the exit operation. The part surrounded by thick lines is the operation newly added in the present invention to the conventional spin lock method and binary semaphore method. (1) Read the lock type variable of the key (step 801)
. Let the read value be c. The lock type variable of the key is set to the busy-wait method (step 802), and the PCB address of the key is set to 0 (step 803). Next, the value c of the lock type variable of the read key is determined (step 804),
If the value of c is the busy way method, go to (2). c.
If the value indicates the semaphore method, the following operations are performed using the binary semaphore function of the general-purpose OS. Check whether the semaphore waiting process queue is empty (step 8)
05), if empty, go to (2). If it is not empty, all processes in the semaphore queue are taken out and placed in the processor waiting process queue (step 806), and the process goes to (2). (2) Set the key lock variable to 0 and complete the exit operation.

[0039]

[Effects of the Invention] The present invention detects that the processor is taken away from a process that has the right to execute the "critical part," and prevents the process from idling and waiting to get the right to execute the "critical part" to take over the processor. By addressing this, it is possible to reduce the waste of processor power due to unnecessary idle operations, or to select whether the mutual exclusion method is a spin lock method or a binary semaphore method, depending on the execution state of the process that has the execution right for the "critical part". By switching, it is possible to reduce the number of times that a process waiting to obtain execution rights for a "critical part" becomes a semaphore waiting process, reduce the number of times that process switching occurs, and keep the overhead of process switching small. Or, the user does not need to select a mutual exclusion method, or it becomes possible to perform exception handling by detecting the occurrence of an error in mutual exclusion,
An advantage is that it can provide an efficient mutual exclusion scheme in systems where user processes frequently perform "tight parts".

[0040]Furthermore, a process waiting to obtain the right to execute the "critical part" may access the process control block (PCB) of the process that owns the right to execute the "critical part".
By mapping into the own address space and then checking its execution status, there is an advantage that the value can be read out at high speed.

Furthermore, when the process that has the right to execute the "critical part" is in the execution state, there is an advantage that there is no write instruction to the memory in the operation procedure in which other processes idle and wait. In the case of a shared memory multiprocessor with a cache, this means only referencing data in the cache memory and no access to main memory or data transfer to other processors' caches. This means that the performance of other processors is not degraded due to idling.

[Brief explanation of drawings]

FIG. 1 is a system configuration diagram of an embodiment of the present invention.

FIG. 2 is a diagram illustrating an operation procedure for mutual exclusion using an inlet operation and an outlet operation in the method of the present invention.

FIG. 3 is a functional block diagram of entrance operation.

FIG. 4 is a processing flow diagram of the locking means in FIG. 3;

FIG. 5 is a processing flow diagram of the lock switching means of FIG. 3;

FIG. 6 is a processing flow diagram of the process execution state monitoring means in FIG. 3;

FIG. 7 is a processing flow diagram of the process execution control means of FIG. 3;

FIG. 8 is a processing flow diagram of an exit operation.

FIG. 9 is a system configuration diagram for explaining a conventional spin lock method.

[Figure 10] Lock operation and unlo with spinlock method
FIG. 3 is a diagram showing an operation procedure for mutual exclusion using a ck operation.

FIG. 11 is a functional block diagram of a lock operation.

FIG. 12 is a processing flow diagram of the locking means in FIG. 11;

FIG. 13 is a processing flow diagram of an unlock operation.

FIG. 14 is a system configuration diagram for explaining a conventional binary semaphore method.

FIG. 15 is a diagram showing an operation procedure for mutual exclusion using P operation and V operation in a binary semaphore system.

FIG. 16 is a functional block diagram of P operation.

FIG. 17 is a processing flow diagram of the lock means and process execution control means in FIG. 16;

FIG. 18 is a processing flow diagram of V operation.

[Explanation of symbols]

1, 2 Processor 3 Main storage device 101 Process control block (PCB) 102
Process waiting process queue 103 Semaphore waiting process queue 104 Key 105 Sensitive part 106 Entrance operation 107 Exit operation 108 Exception handling program 109 Process switching program 301 Lock means 302 Lock switching means 303 Process execution state monitoring means 304 Process execution control means

Claims (3)

[Claims] Claim 1: In a multiprocessor system in which multiple processors and main memory devices are connected via a system bus, and parallel programs consisting of multiple processes that can run simultaneously on different processors run, each process uses shared resources of the main memory device. When accessing the "critical part", the right to start execution (hereinafter referred to as execution right) of a part that can only be used by one process at a time (hereinafter referred to as "critical part") is mutually excluded. The spinlock type, in which a process that fails to obtain the execution right relinquishes the right to use the processor and waits, and the semaphore type, in which the process repeatedly attempts to acquire the right to execute while securing the right to use the processor, are used together, and the A mutual exclusion method for shared resources characterized by switching a process waiting to obtain the right to execute a ``critical part'' to a spinlock type or a semaphore type depending on the execution state of the process that has the right to execute the ``critical part''. Claim 2: A process waiting to obtain the right to execute the "critical part" maps the process control block of the process that has the right to execute the "critical part" into its own address space and checks its execution state. 2. A shared resource mutual exclusion system according to claim 1. 3. The shared resource mutual exclusion method according to claim 1, wherein an error in a program of a process performing mutual exclusion is detected, and the process causing the error is caused to execute exception handling.