JP2011054114A - Method, device, and program for handling memory leak - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To release a memory even when there is a difference in degree or frequency of memory leak of processing, by using software having a memory leak to continue a service and handling the memory leak at intervals regardless of the number of machines. <P>SOLUTION: A process managing means has a means which selects a corresponding number of processing means in accordance with the number of processing means to be simultaneously restarted, issues a stop instruction to the processing means, and repeats processing that receives a restart completion notification from the stopped processing means, for all the processing means. The processing means has a stop control means which selects one queue managing means by an arbitrary algorithm, acquires data from the queue managing means, increases a value of a restart counter in accordance with the risk of a resource leak in accordance with processing or the data while executing the processing corresponding to the acquired data, and stops the process when the counter value exceeds a reference value set beforehand. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a memory leak handling processing method, apparatus, and program, and more particularly, to a memory leak handling processing method and apparatus for providing a service while dealing with a memory release leak (hereinafter referred to as a memory leak) due to software quality. Regarding the program.

  Conventionally, there have been the following technologies premised on the occurrence of memory leaks.

  The first method utilizes an Act-Stby type highly available cluster configuration. The service application server has the above-mentioned cluster configuration, and failover (switch from the active server to the standby server) is executed at predetermined time intervals to reset (restart) the old active OS and service application programs. Thus, the service is prevented from being stopped (for example, see Patent Document 1).

  The second method is a method for minimizing service interruption. This method is mainly used in reference services such as Web services and video streaming services.

  A typical configuration is shown in FIG.

This is a cluster configuration in which an Act server group (machine 2 ₁ to machine 2 _{m in} FIG. 10) having the same content is arranged, and a load balancer (LB) 1 that distributes processing is placed on the front thereof. For the processing requests of 10 ₁ to 10 _x , the LB ₁ distributes the processing to the machines 2 ₁ to 2 _m and responds. If this time there is a possibility of the occurrence of a memory leak in the processing of each machine, for example, considering the machine 2 _1,
(1) First, at the stage where new connections and requests to change set the LB1 so as not to go to the machine 2 _1, it has ended all services that remain on the machine 2 ₁ from each of the additional recording client 10, stop the machine 2 ₁ Release resources and restart.

(2) to re-start the machine 2 ₁ has been completed, with even well-equipped stage start-up of the application program, for LB1, changes the setting to allow a new connection and requests to the machine 2 _1.

The above operation is performed in order for the remaining machines 2 ₂ to 2 _m .

  By periodically performing a series of these operations, it becomes possible to release the memory leak of each machine without stopping the service.

  As a third method, a management server is provided instead of the part called LB (load balancer) in the previous example, and a device to be restarted is selected from a plurality of processing devices based on the evaluation formula. There is a method of selecting a restart server that minimizes the influence of restart (for example, see Patent Document 2).

JP 2001-188684 A JP 2006-31096 A

  However, the first conventional method has a problem that the application program, that is, the service is interrupted during the failover, and is not suitable for a service that requires non-stop.

  Further, the second method has the following problems.

-There is no generalization of the means for confirming service stoppage or application program stoppage, and automation is not possible;
・ It takes time depending on the number of machines before the entire restart;
-Since it will be restarted in units of machines, it takes time to return to the whole;
Because of these problems, it is also a problem that it is not suitable for dealing with high frequency memory leaks.

  In the third method, there is a case where the centralized server portion corresponding to LB generally becomes a bottleneck of the entire system, and it is not a good method in terms of performance to perform evaluation in that portion. It was.

  Similarly, the method of grasping the state of each machine by the LB is not a good method in terms of performance because it increases the load of the single point LB.

The present invention has been made in view of the above points.
-Realize continuous service using software with memory leaks;
・ Do not provide a single point bottleneck at that time;
-Capable of dealing with frequent memory leaks;
An object of the present invention is to provide a memory leak handling method, apparatus, and program capable of performing the above.

  FIG. 1 is a principle configuration diagram of the present invention.

The present invention (Claim 1) is a memory leak handling processing apparatus that provides a service while dealing with a memory release leak (hereinafter referred to as a memory leak) due to software quality,
At least two or more processing means 32 for acquiring and processing data from the queue 21 of the queue management means 20 for queuing and managing data received from outside;
Process management means 31 for managing the processing means 32 group,
The process management means 31
Depending on the restart notification from the operator or periodically, according to the number of simultaneous restarts, select the processing means for the number of simultaneous restarts, instruct each processing means to stop, and stop A restart control means 311 that restarts the processing means 32 for the remaining minutes and repeats the processing for receiving the restart completion notification from the processing means for the stop for all the processing means,
The processing means 32
When one queue management unit 20 is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit 20, and a process corresponding to the data is executed, a resource leak occurs depending on the process or the data. Increase (or decrease) the value of the restart counter according to the risk that occurs, stop when the value of the restart counter exceeds (or falls below) a preset reference value, and stop from the process management means 31 Stop control means 321 for stopping the process when instructed
And a means for performing a restart when a restart is instructed from the process management means 31 and transmitting a restart completion notification to the process management means 31.

The present invention (Claim 2) is a memory leak handling processing apparatus that provides a service while dealing with a memory release leak (hereinafter referred to as a memory leak) due to software quality,
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
Process management means for managing the processing means group,
Process management means
Counting the number of processing means being executed and starting the insufficient processing means if the number does not satisfy the preset number of management target processing means until a stop notification is received from the processing means, or It has a startup control means that repeats regularly,
The processing means is
When one queue management unit is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit, and a process corresponding to the data is executed, a resource leak occurs depending on the process or data. The value of the counter corresponding to the risk is increased (or decreased), and when the restart counter exceeds (or falls below) a preset reference value, the process is stopped and a stop notification is sent to the process management unit. Stop control means to transmit to,
And a means for starting a process when the process management means gives an instruction to start.

Further, the present invention (Claim 3) is the processing means of Claim 1 or 2,
Processing modules for multiple services;
Script control means for combining and executing each service module;
Script storage means for storing a script for realizing at least one service input from the outside in a storage means in association with a process ID;
Script execution means for acquiring and executing a script from the storage means based on data acquired from the queue management means or a processing ID directly or indirectly associated with the queue management means that acquired the data.

  FIG. 2 is a diagram for explaining the principle of the present invention.

The present invention (Claim 4) is a memory leak handling method for providing a service while dealing with a memory release leak (hereinafter referred to as a memory leak) due to software quality,
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
In an apparatus having process management means for managing processing means groups,
The processing means is
One queue management means is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management means (step 1), and a process according to the data is executed. Increase (or decrease) the value of the restart counter according to the risk of leak (Step 2), and if the value of the restart counter exceeds (or falls below) a preset reference value Stop the process, send a stop notification to the process management device (step 3),
Process management means
Depending on the restart notification from the operator or periodically, according to the number of simultaneous restarts (step 4), processing means for the number of simultaneous restarts are selected (step 5), and each processing means is stopped. Instruct (step 6),
The processing means instructed to stop by the process management means is
Stop the process, send a stop notification to the process management means (step 7),
The process management means instructs the stopped processing means to restart (step 8),
The processing means instructed to restart from the process management means,
The process is restarted (step 9), and a restart completion notice is transmitted to the process management means (step 10).

The present invention (Claim 5) is a memory leak handling method for providing a service while dealing with a memory release leak (hereinafter referred to as a memory leak) due to software quality,
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
In an apparatus having process management means for managing processing means groups,
The processing means is
When one queue management unit is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit, and a process corresponding to the data is executed, a resource leak occurs depending on the process or data. Increase (or decrease) the value of the restart counter according to the risk. If the value of the restart counter exceeds (or falls below) a preset reference value, the process is stopped and the process management means A stop control step to send a stop notification to
Process management means
A start control step for receiving a stop notification from the processing means, counting the number of processing means being executed, and instructing a start to start the insufficient processing means if the number of processing target processing means set in advance is not reached Until the stop notification is received from the processing means or periodically,
The processing means is
When an activation instruction is issued from the process management means, the process is activated, and an activation completion notification is transmitted to the process management means.

The present invention (Claim 6) is the processing means according to Claim 4 or 5,
A script that realizes at least one service input from the outside is stored in the storage means in association with the process ID,
Based on the data acquired from the queue management means or the processing ID directly or indirectly associated with the queue management means that acquired the data, a script is acquired from the storage means, and the processing modules for each service are combined and executed.

  The present invention (Claim 7) is a memory leak handling program for causing a computer to function as each means of the memory leak handling apparatus according to any one of Claims 1 to 3.

  The present invention (invention 8) is a computer-readable recording medium in which the memory leak handling processing program according to claim 7 is stored.

  As described above, according to the present invention, there are a plurality of process (processing means) groups for realizing a service, and by restarting some of the process groups, normal use of software having a memory leak is possible. It becomes possible to realize continuous service.

  In addition, there is no need to prepare a service stop confirmation method specialized for individual application programs, which is general-purpose and can be automated.

  Furthermore, by adjusting the increase / decrease value of the restart counter for each processing module, even if processes with different levels and frequencies of memory leaks are mixed, it is possible to release memory leaks according to the processing contents of the process, which is wasteful. It is possible to avoid rebooting the process. (Here, it is also possible to optimize the restart timing by combining observation means for the memory leak amount of the current process and the like as an application range of the present invention.

  In addition, since the present invention sequentially restarts a plurality of processes in one machine, it has a feature that the time required for completion of switching is almost constant regardless of the number of machines, and the work time until the memory leak countermeasure is reduced. Easy to estimate. Therefore, even in an environment where the number of machines increases, it is easy to keep the memory leak countermeasure interval constant, and it is possible to cope with memory leaks in a short time.

  From the above, it is possible to cope with a case where the frequency of memory leak is high.

  In addition, since a central management server such as a load balancer does not exist in the main flow of processing, bottlenecks are unlikely to occur.

  The present invention has an effect that it is possible to cope with even a single machine and that the switching method is the same and easy to understand even when there are a plurality of machines.

It is a principle block diagram of this invention. It is a figure for demonstrating the principle of this invention. It is a system configuration figure in a 1st embodiment of the present invention. It is a figure which shows operation | movement of the queue part in the 1st Embodiment of this invention. It is a figure which shows operation | movement of the process part of the processing machine in the 1st Embodiment of this invention. It is a figure which shows operation | movement of the process management part of the processing machine in the 1st Embodiment of this invention. It is a figure which shows operation | movement of the process management part in the 2nd Embodiment of this invention. 1 is a system configuration diagram (part 1) according to an embodiment of the present invention. FIG. It is a system configuration figure (the 2) in one example of the present invention. It is a conventional system configuration diagram.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

  First, an overview of the approach of the present invention is shown.

  -The process is not a restart from the OS, but a process of an application program (hereinafter sometimes simply referred to as "process" or "application process"), either autonomously or on a regular basis, or restarted by an operator instruction. Release memory leaks.

  ・ Application processes can execute multiple processes with the same function in the same machine, so that the service will not stop even if one process stops.

  -The application process can be executed on a plurality of (many) machines to maintain the scalability of the service. At the same time, by having a plurality of service reception ports, a single point bottleneck such as LB is avoided.

  The application process releases the memory leak by increasing the counter according to the execution of the specific function or the processing of the specific data, and stopping when the counter exceeds the threshold value.

  In addition, a configuration in which one application process includes a plurality of service application programs and switches the processing contents to be executed according to external conditions to perform different service behaviors is allowed. For this reason, there is a problem in that the amount of memory leak differs for each service type and for each route through which processing flows during service execution. Even in this case, the number of restarts of the application process is also minimized.

  For this reason, after a specific processing module has been executed a certain number of times, or automatically according to the remaining memory amount.

[First embodiment]
FIG. 3 shows a system configuration in the first embodiment of the present invention.

The system shown in the figure includes at least two or more queue units 20 _{1 to} 20 _j and at least two or more processing machines 30 ₁ to 30 _m . It is assumed that the processing machine 30 is an ACT server shown in FIG.

Each of the queue units 20 _{1 to} 20 _j queues data received from the outside in a queue area.

Each of the processing machines 30 ₁ to 30 _m includes one process management unit 31 _{1 to} 31 _m for each processing machine 30 and at least two processing units 32 _{11 to} 32 _mk .

  In the present embodiment, a case will be described in which the process management unit 31 restarts the processing unit 32 based on an external trigger such as a notification from an operator or a presentation notification.

4, 5, and 6 are diagrams illustrating the operation of each component according to the first embodiment of the present invention. FIG. 4 illustrates the queue units 20 _{1 to} 20 _n , and FIG. 5 illustrates the processing unit 32 _11. .About.32 _mk , FIG. 6 shows each operation of the process management units 31 _{1 to} 31 _m .

Each of the queue units 20 _{1 to} 20 _n receives data from the write-once client 10 (FIG. 4: Q-AC-1) and adds data to the queue area (FIG. 4: Q-AC-2).

Process management unit ₃₁ 1 to 31 _m of the processing machine ₃₀ 1 to 30 _m waits for the restart notification processing unit 32 by the operator received or until scheduled (Figure 6: MM-1) each of the processing machine 30 ₁ The processing units 32 _{11 to} 32 _mk within ˜30 _m are managed (FIG. 6: MM-2), and the processing units 32 corresponding to the number of simultaneous restarts according to the number of simultaneous restarts (FIG. 6: D-3). Is selected to instruct each processing unit 32 to stop (FIG. 6: MM-3), the number of the stopped processing units 32 are restarted (FIG. 6: MM-4), and the processing units after the restart Reboot completion notification is received from 32 (FIG. 6: MM-5). Each of the process management units 31 _{1 to} 31 _m performs the above processing on all the processing units 32 (FIG. 6: MM-6), and performs the processing according to a restart notification from the operator or periodically. repeat.

  Each processing unit 32 of each processing machine 30 notifies the process management unit 31 of process activation (restart completion notification) (FIG. 5: F-1), and clears the restart counter to zero (FIG. 5: F). -2). One queue unit 20 is selected by an arbitrary algorithm (FIG. 5: F-3), and a data acquisition request is sent to the queue unit 20. The queue unit 20 accepts the data acquisition request (FIG. 4: QF-1), selects data from the old data in the data group without the processing flag, assigns the processing flag, and then processes the requesting processing unit 32. (Fig. 4: QF-2). Thereafter, the queue unit 20 monitors the time-out for the data being processed, and deletes the in-process flag when time-out occurs (FIG. 4: Q-F-3).

  The processing unit 32 acquires at least one piece of data from the queue unit 20 (FIG. 5: F-4) and executes a process according to the data (FIG. 5: F5). Here, it is assumed that an information source ID is assigned to the data, a process corresponding to the information source ID is defined, and the process is executed. The processing unit 32 has a restart counter, and increases (or decreases) the value of the restart counter according to the risk of resource leaks depending on the process or data when the process is executed (FIG. 5: F− 6) The processing completion is notified to the queue unit 20 (FIG. 5: F-7). The queue unit 20 receives a data processing completion notification from the processing unit 32 (FIG. 4: Q-F-4), and deletes the target data from the queue area (FIG. 4: Q-F-5).

  When the restart counter exceeds (or falls below) a preset reference value (FIG. 5: F-8), the processing unit 32 stops the process (FIG. 5: F-10). Note that a stop notification may be transmitted to the process management unit 31 before the process is stopped (FIG. 5: F-9).

Each processor ₃₂ 11-32 processing modules incorporated in _mk are equivalent.

  Through the above series of processes, the memory leak handling module is continuously operated. Thereby, the restart of the processing unit 32 is executed in order according to the operator's instruction and periodic timing, the memory leak is released in order, and the remaining processing unit 32 can continue the service.

[Second Embodiment]
In the present embodiment, a case will be described in which the process management unit 31 of the processing machine 30 monitors the number of processing units 32 being executed and automatically satisfies the processing units 32.

  Since the system configuration in this embodiment is the same as that of the first embodiment described above, description thereof is omitted.

  FIG. 7 is a diagram for explaining the operation of the processing machine according to the second embodiment of the present invention.

  The process management unit 31 monitors the number of processing units 32 being executed in each machine 30 (FIG. 7: MA-2), and if the number is not less than the number of processing units to be managed (FIG. 7: D-2). The insufficiency processing unit 32 is activated (FIG. 7: MA-3), and is repeated every time a stop notification is received from the processing unit 32 in the machine 30 (FIG. 7: MA-1) or periodically.

  Each processing unit 32 of each processing machine 30 starts the process when the process management unit 31 is instructed to start, and sends a start completion notification to the process management unit 31 (FIG. 5: F-1). The restart counter is cleared to zero (FIG. 5: F-2), one queue unit 20 is selected by an arbitrary algorithm (FIG. 5: F-3), and a data request is sent to the queue unit 20. The queue unit 20 accepts the data acquisition request (FIG. 4: QF-1), selects data from the old data in the data group without the processing flag, assigns the processing flag, and then processes the requesting processing unit 32. (Fig. 4: QF-2). Thereafter, the queue unit 20 monitors the time-out for the data being processed, and deletes the in-process flag when time-out occurs (FIG. 4: Q-F-3).

  The processing unit 32 acquires at least one piece of data from the queue unit 20 (FIG. 5: F-4) and executes a process according to the data (FIG. 5: F5). Here, it is assumed that an information source ID is assigned to the data, a process corresponding to the information source ID is defined, and the process is executed. At that time, the restart counter value is increased (or decreased) in accordance with the risk of resource leaks depending on the processing or data (FIG. 5: F-6), and the processing completion is notified to the queue unit 20. (Figure 5: F-7). The queue unit 20 receives a data processing completion notification from the processing unit 32 (FIG. 4: Q-F-4), and deletes the target data from the queue area (FIG. 4: Q-F-5).

  When the restart counter exceeds (or falls below) a preset reference value (FIG. 5: F-8), the processing unit 32 stops the process (FIG. 5: F-10). Note that a stop notification may be transmitted to the process management unit 31 before the process is stopped (FIG. 5: F-9).

Each processor ₃₂ 11-32 processing modules incorporated in _mk are equivalent.

  Through the above series of processes, the memory leak handling module is continuously operated. As a result, when the counter value for restarting the processing unit 32 exceeds a specific value, the restarting is automatically executed according to the stop of the processing unit 32, and the memory leak is sequentially released. The remaining processing unit 32 can continue the service.

  Examples of the present invention are shown below.

  FIGS. 8 and 9 show the system configuration of an embodiment of the present invention. FIG. 8 shows an example when there is an operation instruction, which is restarted by an operation instruction by the operator and control by each process management unit 31. FIG. 9 shows an example in which a queue distribution server is provided. The restart is performed by the process management unit 31 and the stop timing is controlled by the processing unit 32.

  In the following example, there is no particular limitation as data, for example, the following.

-RDB record type and XML;
-Media data such as large objects (CLOB and BLOB), images and sounds;
System logs and processing requests;
・ Web data, life log data, e-mail, etc .;
Various data types handled by a database or a data stream management system can be handled equally in the present invention.

  In the following, an example in which there are the following two types of services is shown, but the same applies even if the types increase.

<Service 1>
If it reacts to the presence sensor, check the horizontal camera image, and if there is a face in the image at that time, perform face recognition to identify the person, and if it is an employee, it must be recorded in the employee DB and recognized. Activate the alarm device.

<Service 2>
Continue to play surveillance camera video.

  The above services are realized by scripts combined with the processing modules described later, and each service is executed by switching the scripts in the same process.

Assume that there are the following human sensor (JINKAN) and Web camera video (WEBCAM001) as information sources. Each input record contains
・ Human sensor:
Information source ID: JINKAN
Output: Human sensor value n (int)-“1” if a person is felt, “0” if a person is not felt
・ Web camera video;
Information source ID: WEBCAM001
Output: Image (jpeg)
As processing modules, the following face detection (extractFace), face recognition (recognitionFace), registration in employee DB (stioreDB), activation of alarm device (alert), message output to terminal (message),
It is assumed that the file is saved (saveAs), the column value reference (Get) of the input record, and the latest record reference (Read) of the information source are incorporated in the processing unit 32.

● Face detection (Face number acquisition)
Name: countFaces ()
Argument: Image (jpeg)
Output: Number of faces (int)
● Face detection (Face image array acquisition)
Name: extraceFace ()
Argument: Image (jpeg)
Output: Face image (jpeg)
● Face recognition Name: recognitionFace ()
Argument: face image (jpeg)
Output: If the face can be recognized, employee code (string)
NULL string if face could not be recognized ● Registration in employee DB Name: storeDB ()
Argument: Employee code Time Output: None ● Start alarm device Name: altert ()
Argument: Alarm seconds n (int)
Output: None ● Output a message to the terminal Name: message ()
Argument: String Output: None ● Save file Name: saveAs ()
Argument: Save destination path
Save target Output: None ● Refer to column value of input record Name: get ()
Argument: Input record column Output: Input record column value ● Reference to the latest record of the information source Name: readLatest ();
Argument: Information source ID
Information source ID column Output: Latest column value of specified column of information source ID The following <APPLICATION_PROGRAM1> and <APPLICATION_PROGRAM2> are provided as service application programs configured by combining the above processing modules with scripts. Suppose there was. These correspond to the implementation of the service 1 and service 2 described above. The following script is written in its own pseudo code, but it may be an equivalent programming language.

<APPLICATION_PROGRAM1>
APPLICATION_PROGRAM1 = {
int T; // Time value of the input record
int R; // Human sensor value of the input record
int T = get (JINKAN, Time); // Get time value
int R = get (JINKAN, Image); // Get human sensor status
if (R == 0) {// End the event if there is no response to the human sensor
return;
}
else {// If it reacts to a human sensor
jpeg J;
J = readLatest (WEBCAM001); // Refer to the image of the next webcam
int num_Face;
num_Face = countFaces (J);
if (num_Face <= 1) {// The human sensor has a response but no face
message ("Detected but no face");
return;
}
else {// The human sensor responded and the face was reflected
int Faces []; // array
Faces = extractFaces (J);
for (int i = 0; i <num_Face; i ++) {// Check if the number of faces is an employee
string C;
C = recognitionFace (Faces [i]);
if (C! = NULL) {// If employee, record in employee DB
storeDB (C, T);
}
else {// Faces other than employees were reflected
message ("Alarm unknown person detection")
alert (3); // alert for 3 seconds
}
}
return;
}
}
}
<APPLICATION_PROGRAM2>
APPLICATION_PROGRAM2 = {
int T; // Time value of the input record
int J; // Human sensor value of the input record
int T = get (WEBCAM001, Time); // Get time value
int J = get (WEBCAM001, Image); // Get camera video status
saveAs ("/var/www/html/camlog/${T}.jpg", J);
return;
}
At this time, as a process, <APPLICATION_PROGRAM1> checks the horizontal camera image WEBCAM001 when it reacts to the human sensor, and if there is a face in the image at that time, it performs face recognition and identifies that person. If it is recorded in the employee DB and cannot be recognized, the alarm device is activated for 3 seconds.

  Further, at this time, <APPLICATION_PROGRAM2> is a process of saving under the html directory as an image having the video camera time as a file name.

  These <APPLICATION_PROGRAM1> and <APPLICATION_PROGRAM2> correspond to F-5 in FIG.

  At this time, memory leaks remain in “recognitionFace” which is the face recognition process and “storeDB” which is the input process to the DB, and it is generally safe to restart “recognitionFace” every time it is executed 100 times. Assuming that storeDB was generally safe to restart after every 5000 executions.

  In this case, the processing unit 32 determines that “recognitionFace” has 50 times as much memory leak amount as “storeDB”, and sets the restart counter +50 once for “storeDB” for one execution of “recognitionFace”. The restart counter is incremented by 1 (Fig. 5: F-6) and the restart counter value exceeds 5000 (Fig. 5: F-8, F-10). If rebootcountup processing is set to rebootCountup (), “rebootCountup (50)” is added as shown in <APPLICATION_PROGRAM1 ′> below. It is assumed that this upper limit value 5000 is specified for the process by some other method (for example, a setting file, a startup parameter, a script declaration, etc.).

<APPLICATION_PROGRAM1 '>
APPLICATION_PROGRAM1 '= {
int T; // Time value of the input record
int R; // Human sensor value of the input record
int T = get (JINKAN, Time); // Get time value
int R = get (JINKAN, Image); // Get human sensor status
if (R == 0) {// End the event if there is no response to the human sensor
return;
}
else {// If it reacts to a human sensor
jpeg J;
J = readLatest (WEBCAM001); // Refer to the image of the next webcam
int num_Face;
num_Face = countFaces (J);
if (num_Face <= 1) {// The human sensor has a response but no face
message ("Detected but no face");
return;
}
else {// The human sensor responded and the face was reflected
int Faces []; // array
Faces = extractFaces (J);
rebootCountup (50)
for (int i = 0; i <num_Face; i ++) {// Check if the number of faces is an employee
string C;
C = recognitionFace (Faces [i]);
if (C! = NULL) {// If employee, record in employee DB
storeDB (C, T);
rebootCountup (1)
}
else {// Faces other than employees were reflected
message ("Alarm unknown person detection")
alert (3); // alert for 3 seconds
}
}
return;
}
}
}
<APPLICATION_PROGRAM1 '> and <APPLICATION_PROGRAM2> are read into each of the processing units 32 _{11 to} 32 _mk in FIGS. 8 and 9 for some reason (startup, operator notification, etc.).

The information sources “JINKAN” and “WEBCAM001” are added to one of the queue units 20 by the additional recording clients 10 ₁ to 10 _x .

Information additional recording client 10 ₁ is "JINKAN" in queue 2 queue unit 20 ₁ in this example, additional recording client 10 ₂ continue to append continuously information "WEBCAM001" queue n of the queue unit 20 _n And

  These will be described in association with the flowcharts of FIGS.

First, the data of the motion sensor JINKAN, for example every second, obtained by additional recording client 10 ₁ (Figure 4: Q-AC-1) is, the data added to the queue 2 in the queue section 20 ₁ (Figure 4: Q-AC-2 ) Will continue.

Similarly, the image data of the web camera “WEBCAM001” is acquired by the appending client 102 (FIG. 4: Q-AC-1), for example, at 4 frames per _second (FIG. 4: Q-AC-1), and the data is appended to the queue n of the queue unit 20n (FIG. 4: Q-AC-2) will continue.

Each of the processing units 32 _{11 to} 32 _mk is first activated by the process management unit 31 (FIG. 5: F-1), clears a restart counter to be used later, holds it in the process space, and stops. Repeat the following process (Figure 5: F-3 to F-8).

  First, an arbitrary one is selected from a plurality of queue units 20 existing in the system (FIG. 5: F-3). This selection method may be a simple method such as round robin or an advanced method using probability.

  It is assumed that the queue unit 20 selected here is the queue 2 in which the data “JINKAN” is additionally written.

The corresponding processing on the queue 2 side receives a data acquisition request (FIG. 4: QF-1) from each processing unit 32, and selects the oldest data in the data group without a processing flag on the queue 2. Then, after the processing flag is put on the queue 2, it is transmitted to the request source processing unit 32 (FIG. 4: QF-2), and in preparation for the stop of the request source processing unit 32, The timeout monitoring is set (FIG. 4: QF-3), and the process returns to the process of waiting for a request from the next processing unit 32. This will be described below a process unit for example as a processing unit 32 _23.

Processing unit 32 _23, the data transmission (Figure 4: QF-2) from the queue 2 selected receiving acquires 1 data (Fig 5: F-4).

  Here, it is assumed that the information that <APPLICATION_PROGRAM1 '> is applied in advance to the data coming from the “JINKAN” information source, and the above-described pseudo code <APPLICATION_PROGRAM1'> is executed (FIG. 5: F -5), and the restart counter is counted up (FIG. 5: F-6).

<APPLICATION_PROGRAM1 '> After the completed, notifies the completion of processing to the queue unit 20 (F-7), and correspondingly, the queue 2 in the queue unit 20, a data processing completion notification from the processing unit 32 ₂₃ (FIG. 4: QF-4), delete the processing flag of the target data and delete the target data from the queue (FIG. 4: QF-5).

Notification of the completion of processing of the queue section 20 (FIG. 5: F-7) was the processing unit 32 ₂₃ has a pre-reference value of the restart as specified in any way, the value of the restart counter held in the process (F-8), the connection destination queue unit 20 is selected again (FIG. 5: F-3). At this time, if the same queue 2 as before is selected, <APPLICATION_PROGRAM1 '> is executed in the same manner, but another queue unit 20 may be selected.

For example, if the queue _n of the queue unit 20 _n is selected, <APPLICATION_PROGRAM2> is executed. In <APPLICATION_PROGRAM2>, “rebootCountup” corresponding to the risk of memory leak is not executed, so the reboot counter is not counted up. This restart counter exists for each processing unit, that is, for each process as a restart unit.

  In the previous comparison (FIG. 5: F-8), if the restart counter exceeds the reference value, a stop notification is sent to the process management unit 31 on the same machine (F-9), and the processing unit 32 Is stopped (FIG. 5: F-10).

  The operation of the process management unit 31 on the same machine in response to this stop will be described.

  The process management unit 31 receives a stop notification from the processing unit 32 (FIG. 7: MA-1), grasps the current number of processing units 32, and is insufficient if the number of managed processing units 32 is not reached. The number of processing units is started (FIG. 7: MA-3), and the monitoring of the number of processing units and the restart of the shortage are the triggers for receiving the stop notification of the processing unit 32 (FIG. 7: MA-1). In addition to this, it is periodically executed (Fig. 7: MA-4, MA-2).

  By restarting the processing unit 32 according to these series of flows, the memory leak occurring in the processing unit 32 is efficiently released.

  Further, not only automatic restart but also restart notification by an operator or periodic restart issuance may be necessary. Such a case will be described below.

  When the process management unit 31 on the machine receives the restart notification of the processing unit 32 by the operator (FIG. 6: MM-1), it grasps all the processing units 32 under management (FIG. 6: MM-2), Select the processing units 32 for the number of simultaneous restarts set in advance (Fig. 6: D-3) and instruct each processing unit 32 to stop (Fig. 6: MM-3), or forcibly delete processes And restart the processing unit 32 for the stop (FIG. 6: MM-4), and receive a restart completion notification from the processing unit 32 after the restart (FIG. 6: MM-5). By performing the steps 6 to MM-3 to MM-5 in all the processing units 32 grasped by MM-2, the memory leak generated in the processing unit 32 is released.

Since the above-described processing is executed in parallel for each process for the process management unit 31 and for all of the processing units 32 _{11 to} 32 _mk for the processing unit 32, a memory leak occurring in the processing unit 32 is prevented. At the same time, the processing that continues to be input from the information source additional recording clients 10 ₁ to 10 _x is also executed by any of the processing units 32. As a result, without stopping the service, By making the restart of some of the processes in the normal state, it becomes possible to realize continuous service using software with memory leak.

  Note that when applied to video as in the service 2, the processing unit 32 processes each screen (frame) independently, so that frame reversal may occur in some cases. When it is necessary to correct the reverse rotation, a frame is transmitted from each processing unit 32 to another joining / aligning unit process once, and after aligning data within a specified time, the data is output to the outside. Will respond.

  The operations of the process management unit 31 and the processing unit 32 of the processing machines shown in FIGS. 3, 8, and 9 are constructed as programs and installed in a computer used as the processing machine for execution, or a network is configured. It is possible to circulate through.

  Further, the constructed program can be stored in a portable storage medium such as a hard disk, a flexible disk, or a CD-ROM, and can be installed or distributed in a computer.

  The present invention is not limited to the above-described embodiments and examples, and various modifications and applications can be made within the scope of the claims.

  Although the present invention mainly deals with memory leaks, resources that are reset or released by releasing process space, such as file descriptors, can be handled in the same way as memory leaks.

10 Additional Client 20 Queue Unit 30 Processing Machine 31 Process Management Unit 32 Processing Unit

Claims (8)

A memory leak handling processing device that provides services while dealing with memory release leaks (hereinafter referred to as memory leaks) due to software quality,
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
Process management means for managing the processing means group,
The process management means includes
Depending on the restart notification from the operator or periodically, according to the number of simultaneous restarts, select the processing means for the number of simultaneous restarts, instruct each processing means to stop, and stop A restart control unit that restarts the processing unit for minutes and repeats the process for receiving the restart completion notification from the processing unit for the stopped amount for all the processing units,
The processing means includes
When one queue management unit is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit, and a process corresponding to the data is executed, a resource leak occurs depending on the process or data. When the value of the restart counter is increased (or decreased) according to the risk, and the value of the restart counter exceeds (or falls below) a preset reference value, and the process management means stops the process. Stop control means for stopping the process when instructed;
A memory leak handling processing apparatus comprising: means for restarting when a restart is instructed from the process management means, and transmitting the restart completion notice to the process management means. A memory leak handling processing device that provides services while dealing with memory release leaks (hereinafter referred to as memory leaks) due to software quality,
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
Process management means for managing the processing means group,
The process management means includes
Counting the number of processing means being executed and starting the insufficient processing means if the number does not satisfy the preset number of management target processing means until a stop notification is received from the processing means, or It has a startup control means that repeats regularly,
The processing means includes
When one queue management unit is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit, and a process corresponding to the data is executed, a resource leak occurs depending on the process or data. Increase (or decrease) the value of the restart counter according to the risk. If the value of the restart counter exceeds (or falls below) a preset reference value, stop the process and notify the stop Stop control means for transmitting to the process management means,
A memory leak handling processing apparatus, comprising: means for starting a process when the process management means is instructed to start; The processing means includes
Processing modules for multiple services;
Script control means for combining and executing each service module;
Script storage means for storing a script for realizing at least one service input from the outside in a storage means in association with a process ID;
Script execution means for acquiring and executing a script from the storage means based on data acquired from the queue management means or a processing ID directly or indirectly associated with the queue management means that acquired the data;
The memory leak handling apparatus according to claim 1, further comprising: A memory leak handling processing method that provides services while dealing with memory release omission due to software quality (hereinafter referred to as memory leak),
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
In an apparatus having process management means for managing the processing means group,
The processing means includes
When one queue management unit is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit, and a process corresponding to the data is executed, a resource leak occurs depending on the process or data. Increase (or decrease) the value of the restart counter according to the risk, and stop the process when the value of the restart counter exceeds (or falls below) a preset reference value,
Process management means
Depending on the restart notification from the operator or periodically, according to the number of simultaneous restarts, select the processing means for the number of simultaneous restarts, instruct each processing means to stop,
The processing means instructed to stop by the process management means is
Stop the process, send a stop notification to the process management means,
The process management means instructs the stopped processing means to restart,
The processing means instructed to restart from the process management means,
A memory leak handling processing method comprising performing a restarting step of restarting a process and transmitting a restart completion notification to the process management means. A memory leak handling processing method that provides services while dealing with memory release omission due to software quality (hereinafter referred to as memory leak),
At least two processing means for obtaining and processing data from a queue of a queue management means for queuing and managing data received from outside;
In an apparatus having process management means for managing the processing means group,
The processing means includes
When one queue management unit is selected by an arbitrary algorithm, at least one piece of data is acquired from the queue management unit, and a process corresponding to the data is executed, a resource leak occurs depending on the process or data. Increase (or decrease) the value of the restart counter according to the risk, and stop the process when the value of the restart counter exceeds (or falls below) a preset reference value, Perform a stop control step to send a stop notification to the management means,
The process management means includes
Start that receives the stop notification from the processing means, counts the number of processing means being executed, and issues a start instruction to start the insufficient processing means if the number of processing target processing means is not set in advance The control step is performed until a stop notification is received from the processing means or periodically,
The processing means includes
A memory leak response processing method, comprising: starting a process when an activation instruction is issued from the process management means; and performing an activation step of transmitting an activation completion notification to the process management means. The processing means includes
A script that realizes at least one service input from the outside is stored in the storage means in association with the process ID,
Acquiring a script from the storage unit based on data acquired from the queue management unit or a process ID directly or indirectly associated with the queue management unit that acquired the data, and executing the processing modules for each service in combination 6. The memory leak handling method according to claim 4 or 5, wherein:   A memory leak handling processing program for causing a computer to function as each unit of the memory leak handling apparatus according to claim 1.   A computer-readable recording medium storing the memory leak handling processing program according to claim 7.

Images