JPH10124331A - Data processing method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To prevent a system from the lack of resources and the reduction of performance due to the increment of threads by reducing the number of stand-by threads up to the number of operating threads when the number of stand-by threads after parallel processing is larger than the number of threads required for system operation. SOLUTION: A thread program is entered. While referring to a common memory, whether a stand-by flag is ON or not is checked (S22). Just after the generation of a thread, a stand-by flag corresponding to the thread is OFF. Then processing data are acquired from the common memory and processing for executing parallel processing is executed (S25). Then whether a thread number in the common memory is smaller than a regulated value indicating the number of threads at the time of normal system operation or not is checked (S26). When the thread number is larger than the regulated value, a use/unused flag, a stand-by flag and processing data in the common memory are cleared (S28).

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a data processing method, and more particularly, to a method of managing creation and deletion of a thread in a data processing system.

[0002]

2. Description of the Related Art In a data processing system using a computer, for example, a specific function may be executed in parallel with the execution of a main program, for example, in parallel with the processing of the main program. The parallel processing is performed using, for example, a thread. When this thread is used, attempts have been made to reduce and reduce the thread generation time by reusing the once generated thread without deleting it, and to speed up the processing in the system.
For such a technique, see, for example,
7 and JP-A-6-318191. An example of conventional data processing using such a thread will be described below with reference to FIGS.

First, in FIG. 6, the number of recyclable threads is checked (step S31). Such a number check can be determined from the count value of the recycle thread count G in FIG. If the number is 0, there is no recyclable thread, and the process shifts to step S36 and the subsequent steps to generate a thread. On the other hand, the above number is not 0,
If there is a recyclable thread, the use / unused flag B of each thread is checked sequentially from the top of the thread management table, and the status of these used / unused flags is checked (step S32).

If the use / unused flag is off and there is an unused thread, the use / unused flag of the thread is turned on, that is, in use (step S3).
3) Further, data necessary for processing is set in the processing data D of FIG. 8 (step S34). Further, a thread resumption process is performed based on the thread number (handle value) A in FIG. 8 (step S35).

On the other hand, when the use / unused flag is off and there is no unused thread, an empty area in the thread management table at a position skipped by the number of recyclable threads from the top of the table is deleted. The used / unused flag in this empty area is set to be in use (step S36). Also, the number of the area from the top of the thread management table is set as the thread number in this empty area (step S37). And a thread is created as described above,
Since the number of recyclable threads has increased, the recycle thread count G in FIG. 8 is incremented by 1 (step S).
38).

Next, in order to designate the area set as described above as a shared memory between the thread and the main program, the address of the area in the thread management table where the data is set is set as the shared memory address designated when the thread is created. It is assigned to the address E in FIG. 8 (step S39). As a result, the thread generation processing is completed, and thereafter, the processing of steps S34 and S35 is performed to instruct the execution of the thread.

Here, the shared memory is for a thread to operate by referring to it. If a thread is required, an unused thread is searched from the management table, the used / unused flag of the area in the management table corresponding to the unused thread is set to “in use”, and the thread required for the operation of the thread is used. Data is set in a predetermined area, and then the parent thread performs iridium of the thread as an operation trigger to instruct a processing operation. Further, the thread acquires necessary data from the shared memory area with the allocated parent thread and starts operation. Further, by rewriting the shared memory, the parent thread can instruct and execute a predetermined operation to the thread.

FIG. 7 shows a procedure of parallel processing in a thread. The thread fetches a thread program and starts executing the parallel processing. First, immediately after the thread is created, the thread suspends itself and enters a standby state (step S42). Note that suspending refers to suspending a thread to bring it into a resumable standby state. Then, when the above-described restart instruction is issued, the thread acquires the processing data from the shared memory F and executes the parallel processing (step S43). further,
After the execution of the parallel processing, the processing data area is cleared, the used / unused flag B is set to unused, and the apparatus enters the standby state again (step S42).

As described above, all the threads become recyclable threads, and are always in a standby state when not used. In addition, thread deletion
Not done until the system shuts down.

[0010]

When a load is imposed on the data processing system as described above, the number of threads naturally becomes larger than that during normal system operation. Then, in the case of the above-mentioned conventional method, the number of threads is larger than the number during normal operation, for example, as shown in FIG.

However, in the prior art, when the normal operation is resumed after the number of threads increases, the number of threads remains increased as shown in FIG. For this reason, there has been a problem that a plurality of unused threads are in a standby state, and continue to use system resources unnecessarily.

Further, even when the thread is in the standby state,
A very small value, but consumes CPU time. Therefore, according to the above-mentioned conventional method, when the system returns to the normal operation after the system is loaded, the waiting thread C
The consumption of PU time increases. For this reason, there is also a problem that the processing performance of the system during operation when returning to normal operation is reduced.

An object of the present invention is to provide an improved data processing method capable of preventing a shortage of system resources and a decrease in performance due to an increase in threads as described above.

[0014]

A data processing method according to the present invention is a data processing method for performing parallel processing by a plurality of threads on a predetermined data processing system. The number of threads required for the process is set to a standby state in which parallel processing can be resumed, and threads exceeding the specified value are deleted after execution of parallel processing.

Here, the number of prescribed values required for system operation means any number or prescribed value used in normal operation on the system. Such a specified value changes according to the system, and may be an arbitrary value according to the system.

That is, in the present invention, when the number of standby threads after the parallel processing is larger than the number of threads (operation threads) required for system operation, the number of standby threads is reduced to the number of operation threads. It was made.

In order to delete a thread after the execution of the parallel processing as described above, for example, a predetermined thread number is sequentially set for each thread used for the parallel processing, and each thread is set immediately after the execution of the parallel processing. A procedure is used in which a thread number is compared with the specified value, a thread whose thread number is larger than the specified value is deleted, and a thread whose thread number is equal to or smaller than the specified value is placed in the standby state.

[0018]

Embodiments of the data processing method according to the present invention will be described below. FIG. 1 shows an outline of processing in a data processing system to which the present invention is applied. When it is necessary to perform parallel processing by a plurality of threads during execution of the main program, the processing A described below is performed in the main program, and each thread (thread 1 to thread n) is executed.
, The following processing B is performed.

First, the processing A in the main program of the data processing system, that is, the thread management processing in the main program will be described with reference to FIG. This processing is performed as in the following (1) to (4). (1) When parallel processing is required, it is checked whether the recycle thread count is 0 and whether a recycle thread exists (step S1).

The recycle thread counter is set in a predetermined thread management table of the data processing system, for example, as exemplified by reference numeral G in FIG. 4, and the number of recyclable threads in the thread management table is set. It shows. The thread management table has shared memories F corresponding to the number of threads managed by the table. Each shared memory F has a thread number (handle value) A, a used / unused flag B , The standby flag C, and the processing data D are set.

Here, the thread number A indicates a number sequentially set for the threads managed in the thread management table. The used / unused flag B is for indicating the use state of each thread. Further, the wait flag C is for indicating that the thread is not immediately after generation but a recyclable thread. Further, the processing data D is for providing data necessary for parallel processing from the main program to the thread.

If the recycle counter is 0, that is, if there is no recycle thread, the process proceeds to the following process (4) to execute a thread generation process. If the recycle counter is not 0,
Proceeding to the process of (2) below, it is checked whether or not there is a usable recycling thread.

(2) The used / unused flag B in the thread management table corresponding to the recycled thread count is checked (step S2). If there is no unused recycling thread, the process proceeds to the thread generation processing of (4) below. If there is an unused recycling thread, the process proceeds to the following (3) using a recycling thread.

(3) To use a recycled thread, first, the standby flag C of the management table specified in the shared memory of the thread to be used is turned on (step S3). Next, the used / unused flag B is turned on to be used (step S4), data necessary for parallel processing is set in the processing data D (step S5), and the thread is restarted (step S6). Then the thread
The process is released from the standby state from step S29 and restarted, and the recycling process (S29) shown in FIG. 3 is performed.

(4) The thread generation process is performed as follows. First, the waiting flag C of the shared memory F of the thread to be used is turned off (step S7).
Next, the used / unused flag B in the shared memory F
Is in use (step S8). Further, the thread number A of the shared memory F in the thread management table is set to the thread number A, and data necessary for the parallel processing is set in the processing data D (step S9). Next, as a determination as to whether or not this thread will be used as a recycling thread in the future, it is checked whether the thread number A is larger than the number of threads normally used in the data processing system (specified value) (step S10). Since it is used as a recycled thread, the recycled thread count G in the thread management table is incremented by 1 (step S11). Then, the shared memory F of the area set and set in the thread management table as described above.
Is designated as a shared memory between the main program and the thread, and a thread is generated (step S12). In addition,
The thread generated in this way starts processing from step S21 in FIG.

Next, the processing in each thread will be described with reference to FIG. This process is divided into two processes, that is, a process immediately after thread creation and a process at the time of thread recycling.

First, the processing in the thread immediately after the creation of the thread is as follows. First, as a thread generation process, a thread program is fetched, and the thread generation process is started (step S21). Next, it is checked whether or not the standby flag C is turned on with reference to the shared memory F (step S22). Here, immediately after thread creation, the waiting flag C corresponding to the thread is turned off. Then, processing for acquiring the processing data D from the shared memory F and executing the parallel processing is performed (step S25).

Next, it is checked whether or not the thread number A of the shared memory F is smaller than a specified value of the number of threads during normal system operation (step S26). If the thread number A is larger than the specified value, the used / unused flag B, the standby flag C, and the processing data D in the shared memory F are cleared, and the process ends (step S28). Clearing the used / unused flag B means that the shared memory F is unused. Clearing the processing data D means deleting the thread.

If the thread number is smaller than or equal to the specified value, the standby flag C in the shared memory F is turned on (step S27), and the process proceeds to step S22. Then, step S2
In step 2, since the standby flag C is ON, step S23 as a recycling process, that is, a process of clearing the processing data D and setting the use / unused flag B to unused is performed. Next, in step S24, the thread suspends itself and enters a standby state.

Next, processing at the time of thread recycling will be described. This processing is performed as in the following (11) and (12).

(11) That is, at the time of recycling, the thread starts from the state of suspending and waiting in step S29. Then, since the standby is released from the main program, the processing data D is acquired from the shared memory F, and the parallel processing is executed (step S25).

(12) Next, it is checked whether or not the thread number A of the shared memory is smaller than a specified value of the number of threads during normal system operation (step S2).
6). Then, since the thread number A is smaller than the specified value, the standby flag C of the shared memory F is turned on (step S27), and the process proceeds to step S22. Then, in step S22, since the standby flag C is on, steps S23 and S24, which are recycling processes, are performed.

In the data processing method according to this embodiment configured as described above, even if the system is overloaded and the number of threads temporarily increases as shown in FIG. As shown in II in FIG. 5, threads other than those necessary for normal system operation are deleted, and only those necessary threads are put into a standby state and become recyclable threads.

As a result, the consumption of CPU time used when unnecessary threads are in a standby state as in the related art is reduced, and a decrease in system performance after a load occurs can be prevented. In addition, effective use of system resources is eliminated by generating and continuing to useless threads, so that effective resources of the system can be secured. Further, since the system is configured to recycle a necessary number of threads in a standby state in a normal state in the system, the time required to generate and delete the threads is reduced, and the performance of the system can be improved.

[0035]

As is apparent from the above description, according to the present invention, there is an effect that a shortage of system resources and a decrease in performance due to an increase in threads are suppressed.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram showing an outline of processing in a data processing system to which the present invention is applied.

FIG. 2 is a flowchart illustrating a thread management process in the data processing system according to the embodiment;

FIG. 3 is a flowchart showing processing in each thread in the data processing system according to the embodiment;

FIG. 4 is an explanatory diagram of a thread management table in the data processing system according to the embodiment;

FIG. 5 is an explanatory diagram showing a transition of the number of threads in the data processing system according to the embodiment;

FIG. 6 is a flowchart illustrating processing in a conventional data processing system.

FIG. 7 is a flowchart illustrating processing in a conventional data processing system.

FIG. 8 is an explanatory diagram of a thread management table in a conventional data processing system.

FIG. 9 is an explanatory diagram of a change in the number of threads in a conventional data processing system.

[Explanation of symbols]

 A thread number B used / unused flag C wait flag D processing data G recycled thread counter F shared memory

Claims (2)

[Claims] In a data processing method for performing parallel processing by a plurality of threads on a predetermined data processing system, after executing the parallel processing, a predetermined number of threads required for system operation of the data processing system are processed in parallel. A data processing method in which a standby state in which processing can be resumed is set, and threads exceeding the specified value are deleted after execution of parallel processing. 2. A method according to claim 1, wherein a predetermined thread number is sequentially set for each thread used in the parallel processing, and immediately after the execution of the parallel processing, the thread number of each thread is compared with the specified value. 2. The data processing method according to claim 1, wherein a thread whose thread number is larger than the value is deleted, and a thread whose thread number is equal to or less than the specified value is set in the standby state.