JP3582756B2 - Memory management method - Google Patents

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a memory management method when a program is created in an interpreted language.
[0002]
[Prior art]
In an interpreter language that performs character string processing, all data is represented by character strings. When handling an object in such a language, a reference to the object is represented by a character string (hereinafter, referred to as a handle). Usually, memory allocation and deallocation is required for object reference. When creating a program that requires such memory management, the program creator is always aware of whether the object is being referenced, that is, whether the handle may be used again. The operation to release the memory was incorporated in the program.
[0003]
[Problems to be solved by the invention]
As described above, when producing a program using objects that require memory management, the program creator must always correctly recognize whether or not the objects are referenced. This is because if the memory of the referenced object is released, access to the released memory occurs, and if the memory of the object that is no longer referenced is not released, the memory is wasted and the memory becomes insufficient. Occurs, and such a memory management error causes a serious program error.
[0004]
In the interpreted language, since the contents of variables can be monitored at the time of execution, an interpreter that interprets and executes a program on behalf of a program creator can monitor whether or not an object is referenced. However, in the conventional interpreter language that performs character string processing, the part (handle) indicating the object embedded in the character string is not monitored, so the memory of the object using the handle must be stored by the program creator. And there is a problem that the work efficiency of the program production is poor.
[0005]
An object of the present invention is to provide a memory management method that does not require memory management by a program creator even in an interpreted language that mainly performs character string processing.
[0006]
[Means for Solving the Problems]
In order to solve the above-mentioned problem, the present invention selects a character that is used less frequently from a large number of characters used in the interpreter, and uses a character string (handle) including an identification symbol composed of a sequence of the characters to execute memory management from the interpreter. Represents a reference to an object that requires a handle, defines a data structure in the interpreter language corresponding to the handle (handle structure), defines the number of references to the handle as data in the handle structure, and interprets the variables in the interpreter language. Every time the reference state of an object is changed by changing the object, the number of references in the handle structure corresponding to the object is increased or decreased, and the memory management is performed by monitoring the number of references. To allow the interpreter to monitor the reference status of Assigning Mori, and can be managed by releasing the interpreter side.
[0007]
In addition, a pointer to the object is defined as data on the handle structure, and an array or list of the handle structure is prepared, and the index using the character string of the handle as a key and the index using the pointer value indicating the object as a key are used. The preparation enables high-speed processing.
[0008]
BEST MODE FOR CARRYING OUT THE INVENTION
A handle that represents a reference to an object starts with a special character sequence that does not normally appear, followed by a different character string for each handle. For example, "&#% A character string such as $ 000123 "is formed. Here, “&#% ＄” is an identification symbol, and characters that are not frequently used in ordinary sentences, for example, ~ ,! , ＠, #, ＄,%, ＾, & etc., a plurality of characters selected are arranged, and a character string that is very unlikely to be used in ordinary sentences is used. “000123” is a character string that differs for each handle. The interpreter can find the handle by searching the character string in the variable for the identification symbol.
[0009]
It is necessary to release the memory of an object when the object is no longer referenced from anywhere. Whether it is referenced can be determined by whether a handle exists somewhere in the data area of the running program.
[0010]
FIG. 1 shows an example of an embodiment of the present invention, and has the following data configuration.
[0011]
1. A structure including the following contents (hereinafter, referred to as a handle structure) is prepared for managing the handle.
1. Pointer pointing to the object. Flag indicating whether the memory of the object needs to be released. Prepare an array or list of handle structures. The element of this array or list should be immediately known from the string of the handle. For example, an index is formed using a handle string as a key so that the corresponding handle list element can be obtained immediately.
[0012]
3. The handle structure should be found as fast as possible from the pointer value pointing to the object. For example, an index using a pointer value as a key is used.
[0013]
Next, the operation of the method of the present invention will be described.
[0014]
1. When a handle is needed (when an event of referring to an object occurs during data processing in the interpreter), a handle structure is searched using a pointer to the object as a key. If there is already a handle structure, use the handle of that structure. If the handle does not yet exist, a new handle structure element is created or an unused handle structure is searched for and information is set there. If the object pointed to by the handle needs to free memory later, set its flag. The reference number of the handle is set to 0.
[0015]
2. The following processing is performed when changing variables related to the object reference of the interpreter.
[0016]
Search for the character string previously set in the variable and look for the handle identification symbol. Since each handle found has no reference due to this change, the number of references in the handle structure is reduced by one. For example, considering the case where the variable A is replaced by the variable B by the assignment operation, the number of references to the handle related to the variable A is reduced.
[0017]
-Search for a character string to be newly set in the variable, and search for the identification symbol of the handle. Since the reference of each found handle is increased by this change, the reference number of the handle structure is increased by one. For example, considering the case where the variable A is replaced by the variable B by the assignment operation, the reference number of the handle related to the variable B is increased.
[0018]
3. When it is no longer necessary to release the memory of the object (for example, when the object is passed to a subroutine that releases the memory of the object internally during data processing), a flag indicating the need to release the memory of the handle structure is set. I lie down. Conversely, when it is necessary to release the memory of the object again (for example, when a subroutine for assigning the memory management right of the object is called during data processing), it indicates the need to release the memory of the handle structure. Set the flag.
[0019]
4. If the memory of the object is released for some reason (for example, if a subroutine that releases the memory of the object internally during data processing releases the memory of the object), the element of the handle structure is also deleted.
[0020]
5. The interpreter searches each element of the handle structure at some timing, and deletes the handle structure whose reference number is 0. At this time, the memory of the object is released if necessary.
[0021]
FIG. 2 shows an operation flowchart of the method of the present invention. In this figure, the above processes 3 and 4 are omitted. Also, the timing of performing the process 5 is described as when the variable is changed. The processing of 5 may be performed at any time after the start of the interpreter,
(1) 2. (2) When the program is in a waiting state, (3) When the upper limit of the number of handles or the upper limit of the allocated memory is reached. (1) is a method of monitoring the most minutely, (2) is a method that does not burden the interpreter, and (3) is an intermediate between (1) and (2) and operates in response to the need for monitoring.
[0022]
Here, there is a possibility that the same character string as the identification symbol is accidentally included in the data character string as a normal character string, but there is no problem if it is not recognized as a handle if there is no corresponding handle structure. . This can be easily achieved by treating a portion other than the identification symbol in the character string as a character string on ordinary data, instead of the identification symbol of the handle structure.
[0023]
Also, if the same string as the handle in use is used as a normal string, the reference number of the handle structure is set to be larger than the original reference number while the string exists in the variable, Even if the original reference number becomes 0, the memory of the object is not released. However, there is no practical problem since the memory is released when the character string exactly the same as the handle used as the normal character string is no longer stored in the variable. The problem of wasting memory occurs only when a large number of character strings identical to the handle are permanently present in the data. However, as described above, originally used characters that are rarely used are selected as the string for the handle. It can be considered that it is unlikely that the same character string as the handle continues in large quantities.
[0024]
【Example】
An embodiment will be described in which Tcl is used as an interpreter language for performing character string processing, and an instance of the C ⁺⁺ language is used as an object requiring memory management.
[0025]
Tcl is an application-independent and extensible command interpreter library. References to Tcl include "Tcl and the Tk Toolkit", John O. Osterhout, Addison-Wesley, 1994.
[0026]
This embodiment corresponds to a case where an application program interface (API) using Tcl is added to a program manufactured in the C ⁺⁺ language. Such an API can combine the advantages of an interpreted language such as Tcl, which requires no compilation and can be executed immediately, and the advantages of a compiled language that operates at high speed, such as the C ⁺⁺ language. There is a feature.
[0027]
In such an API, a command is added to Tcl, and a C ⁺⁺ program is called in the command. When the called C ⁺⁺ program returns some C ⁺⁺ instance to the Tcl side, since all data is a character string in Tcl, a handle indicating the C ⁺⁺ instance is generated from the C ⁺⁺ instance and returned. When the C ⁺⁺ instance previously obtained from the Tcl side is passed to the added Tcl command, the handle is passed. ^{C ++} program called from the command, with the pointer to the ^{C ++} instance from the ^handle, carrying out the processing for the ^{C ++} instance.
[0028]
In Tcl, all data is a character string, and the character string is referenced by a variable. If there is no handle pointing to a C ⁺⁺ instance anywhere in the string referenced by all variables representing data, the C ⁺⁺ instance will not be referenced again, so it can be deleted. . Note that “delete” is a memory release instruction in the C ⁺⁺ language.
[0029]
Therefore, when inserting a character string into the variable of Tcl, if the existence of the handle in the character string is checked and the existence state of the handle is completely grasped, memory management can be performed on the API side, and the API is used. Program creators do not have to manage memory.
[0030]
An example of a specific procedure of the method will be described below.
[0031]
1. A structure including the following contents (hereinafter, referred to as a handle structure) is prepared for managing the handle.
· C ⁺⁺ pointer, C ⁺⁺ of whether the number of reference handle structure whether an instance of the class-C ⁺⁺ for instance it is necessary to delete one of the flag handle is used flags 2 to refer to instances of. Prepare an array of handle structures that are large enough. Handle names are created from the element numbers of this array. In other words, the element number of the array of the handle structure is known from the name of the handle. For example, if the handle is “&#% $ 000003”, the handle structure corresponding to this handle is obtained as “xxxx [3]”.
[0032]
3. For each element of the handle structure, a hash table using a pointer pointing to an instance of C ⁺⁺ as a key is created and registered in the hash table. That is, it is necessary to find the handle structure from the pointer value as quickly as possible. A hash table is a table of a certain size. To distribute each element in this table as evenly as possible, the key is converted to a numerical value within the range of the table size by a hash function, The element is stored at the position. At the time of retrieval, the key can be converted into a numerical value by a hash function, and an element can be searched from the position of the numerical value in the table, thereby performing high-speed retrieval.
[0033]
4. When a handle is needed, such as when a handle is returned from a command added to Tcl as an API, an element of the handle structure is searched from the hash table using a pointer pointing to an instance of C ⁺⁺ as a key. If an element of the handle structure already exists, a handle name is created and returned from the element number of the array of the element. If the handle does not yet exist, an element of the handle structure that is not used is searched for, and information is set there. If the C ⁺⁺ instance pointed to by the handle must be deleted later, set its flag. The reference number of the handle is set to 0.
[0034]
5. In Tcl, the part where the substitution into the variable is performed is modified as follows.
[0035]
Search the character string previously set in the variable to find each handle referenced from this character string. Since each handle has no reference due to this assignment, the number of references to the handle is reduced by one.
[0036]
Search for a character string newly assigned to a variable, and search for each handle referenced from this character string. Since the reference of each handle is increased by this substitution, the reference number of the handle is increased by one.
[0037]
After the assignment is completed, if any of the handles whose reference number has changed by this assignment has a reference number of 0, the handle structure of the handle is set to unused, removed from the hash table, and the C ⁺⁺ instance is executed. If necessary, delete is performed.
[0038]
6. In Tcl, a part that invalidates a variable (for example, a part in which a local variable of a procedure is discarded by return) is remodeled, and processing for reducing the number of references of a handle that is no longer referred to is included. If there is a handle whose reference number has become 0 due to the invalidation of the variable, the handle structure of the handle is set to unused, and the handle structure is removed from the hash table, and if the C ⁺⁺ instance needs to be deleted, the delete is executed.
[0039]
7. Handle is returned to the pointer to the C ⁺⁺ instance through commands added to Tcl as API, it is passed to a function of C ^++, if the memory management is shifted to C ⁺⁺ program side within the function, a handle structure Lose flag of need for delete.
[0040]
8. Remodeled destructor of C ^{++ instance,} if ^{the C ++} instance is delete a ^{C ++} program side, sets the pointer to the handle structure Seeking ^{C ++} instance that points to the ^{C ++} instance to NULL. At the same time, the handle structure is removed from the hash table using the pointer to the C ⁺⁺ instance as a key.
[0041]
By managing the unused handle structure and the handle structure having a reference number of 0 by respectively connecting them to a dedicated list, processing can be performed at higher speed.
[0042]
【The invention's effect】
As described above, according to the present invention, even in an interpreted language that performs character string processing, efficient program production can be performed without performing memory management, and serious program errors due to erroneous memory management can be achieved. Can be completely eliminated.
[Brief description of the drawings]
FIG. 1 is a data configuration diagram showing an example of an embodiment of the present invention. FIG. 2 is an operation flowchart of a method of the present invention.

Claims (2)

In a memory management method for managing an object memory using an interpreter language that performs character string processing,
Infrequently used characters are selected from a large number of characters used in the interpreter, and a character string (handle) including an identification symbol composed of the character sequence represents a reference from the interpreter to an object requiring memory management,
In addition to defining a data structure (handle structure) in the interpreter language corresponding to the handle, the number of references to the handle is defined as data in the handle structure,
Each time the reference state of an object is changed by changing a variable in the interpreter language, the number of references in the handle structure corresponding to the object is increased or decreased, and memory management is performed by monitoring the number of references. Characterized memory management method. Define a pointer to the object as data on the handle structure, prepare an array or list of handle structures, and prepare an index using the character string of the handle as a key and an index using the pointer value pointing to the object as a key 2. The memory management method according to claim 1, wherein:

Images