KR100497722B1 - Method for controlling memory data storage area, computer readable medium storing the method thereon, and application program executing device - Google Patents

Abstract

When the heap variable definition command is detected so that it is possible to determine whether the variable corresponding to a specific space of the stack is a heap variable in a short time and stably even if it is not stored as separate data. The heap variable address corresponding to the heap variable is stored at a specific address of the heap variable, the heap slot address is stored in a heap area of the heap slot pointer address calculated from the heap variable address, and the set condition is stored in the memory of the heap slot address. Stores a reference value that satisfies

Description

METHOD FOR CONTROLLING MEMORY DATA STORAGE AREA, COMPUTER READABLE MEDIUM STORING THE METHOD THEREON, AND APPLICATION PROGRAM EXECUTING DEVICE}

The present invention relates to a method, an apparatus for managing a data storage space of a memory, and a recording medium recording the method. More particularly, the present invention relates to a program for accessing a data storage space of an application program or a memory of the data storage space of the memory. The present invention relates to a method, an apparatus, and a recording medium recording the method for recovering a space which is not used.

Recently, various electronic devices including computers have been put into practical use, and these are equipped with microprocessors (hereinafter referred to as "CPU") which operate by a set program. The CPU is connected to a memory semiconductor (hereinafter referred to as "memory") for storing data necessary during the execution of an embedded program or a program using the embedded program.

In some cases, the memory semiconductor stores not only data but also a set of instructions for utilizing the functions of the CPU and the memory, called an operating system (hereinafter referred to as "OS"), and A set of instructions (hereinafter referred to as an "application") that performs various functions using the functions (functions or subroutines) of the operating system may also be stored.

Regardless of whether the CPU or the memory is stored in a particular program currently being executed, the data storage space (hereinafter referred to as "memory data space") of the memory is usually accessed during the execution of the program. In order to increase the utilization of the data space, reallocating the memory so that other programs can use the data space (hereinafter referred to as "Garbage") of the memory that is not in use by the current program. Reallocating memory for use of waste space is called "Garbage Collection". The memory reallocation typically changes the allocation of memory to keep the closed space under management of the OS.

Typically, accesses to memory in a program are made by defining variables, which are defined in the address of a specific space (hereinafter referred to as a "stack") of memory.

The definition of such a variable is largely related to variables that directly call a value stored at an allocated address in the stack of the defined variable (hereinafter referred to as a "stack variable") and an allocated address in the stack of the defined variable. A variable that stores specific address data in memory and stores its value in a data space (hereinafter referred to as "heap") of the memory corresponding to the stored address data (hereinafter referred to as "heap variable") It is roughly divided into.

Examples of the stack variables include integers, real numbers, and various other examples. Examples of the heap variables include pointer variables.

For such garbage collection, it is necessary to determine whether a specific address in the data space of the memory is garbage (hereinafter referred to as "Garbage Detection"), and then to the lung space. If so, the memory must be reallocated ("Garbage Reclamation") so that other programs can use that particular address.

This problem of waste space recovery is mainly related to the heap.

1 is a view for explaining a conventional closed space discrimination method.

As shown in FIG. 1, in the data space of a memory, a stack 110, which is an area of addresses corresponding to a variable defined in a program, and a space for storing values of the heap variable when the variable is a heap variable. The heap 120 and a memory allocation table area for storing the start address of the variable values stored in the heap and the size data of the memory occupied by the variable value are formed.

For example, a conventional process of allocating a data space of a memory by a series of instruction sets as shown in Table 1 below based on C is as follows.

Heat command First row  void test () Second row  { Third row int intVar = 1240; Fourth row long longVar = 1240; Fifth row Object * objVar = new Object (); Sixth row .... The seventh row  }

Table 1

When the command of the third column is executed, the value 1240 of the stack variable “invVar” is stored in the first space 111 of the stack 110. Similarly, when the command of the fourth column is executed, the stack ( In the second space 112 of 110, a value 1240 of the stack variable “longVar” is stored.

When the command of the fifth column is executed, in order to allocate a space for storing the value of the heap variable “objVar” to the heap 120, (1) the third space 113 of the stack 110 includes the heap ( 120 stores address data of the set first space 121, and (2) in the specific space 131 of the memory allocation table area 130, the start of the first space 121 of the heap 120; Size data Δ of memory for storing an address (####) and a value of the heap variable “objVar” are stored.

In the instruction set of Table 1, for example, one heap variable is defined, but when a plurality of heap variables are defined, the plurality of spaces in the heap 120 are allocated to the variables, and the memory allocation table area ( 130, the plurality of spaces are used.

In the state where the memory is used as described above, the process of determining whether the target is a normal closed space discrimination process, in particular, whether it is a closed space is as follows.

That is, the value is retrieved for each variable space formed in the stack 110 to determine whether the value is included in the memory allocation table stored in the memory allocation table region 130.

Referring to FIG. 1, it is determined whether the value 1240 stored in the first space 111 of the stack 110 is included in the memory allocation table stored in the memory allocation table region 130. Compare all the values in the memory allocation table.

The same process is repeated with respect to the second space 112 and the third space 113 of the stack 110. Accordingly, the first and second spaces 111 and 112 of the stack 110 are determined to be closed spaces. As the unnecessary space, the third space 113 is determined to be a space in which it is necessary to determine whether it is a closed space.

When the data stored on the stack is stored as a separate data, whether it is a variable value of a stack variable or an address information of a heap variable (hereinafter referred to as a "type of variable"), it is largely determined whether such a waste space is determined. This should not be a problem, but there are various application execution environments in which variable types cannot be stored and managed separately. In practice, variable types are not stored / managed in an application execution environment created using many languages such as C and C ++.

Therefore, in the case where the variable type is not stored / managed in this way, according to the conventional method, if m items exist in the memory allocation table for n data, it is determined whether the variables should be considered for waste space recovery. In order to do this, at least n * m comparisons are required.

Therefore, the present invention manages the data storage space of the memory that can perform the waste space discrimination more quickly and stably even if the variable corresponding to the specific space of the stack is not stored as a separate data. It is an object of the present invention to provide a method, a recording medium recording the method, and an application program execution device using the method.

In order to achieve the above object, the memory data storage space management method according to the present invention stores a heap variable address corresponding to the heap variable at a specific address of a stack when a heap variable definition instruction is detected, and stores the heap variable address from the heap variable address. The heap slot address is stored in the calculated heap slot pointer address heap area, and a reference value satisfying a set condition is stored in the heap slot address memory.

The memory data storage space management method of the present invention preferably further includes a step of determining whether or not a variable area for waste space recovery. As the process of determining whether or not a variable area is used, a value stored in the stack is used as the heap variable address. Calculates a heap slot pointer address, extracts a reference value stored at an address indicated by the value stored in the calculated heap slot pointer address, and, when the reference value satisfies the set condition, sets the value stored in the stack as an address. The method may further include a data storage space retrieval step of determining whether to recover the variable value storage space of the heap variable.

Preferably, the heap slot pointer address is calculated to be one data area preceding the heap variable address.

The set condition may be any condition. For example, the set condition may be a condition equal to the heap slot pointer address or a preset value.

In order to further facilitate the convenience of the programmer, the memory data storage space management method of the present invention may detect a prohibition instruction for instructing not to perform a waste space recovery on a heap variable defined by the heap variable definition instruction. Storing a predetermined prohibition code in a memory of a flag address calculated from the hipslot address; And when the setting command corresponding to the prohibition command is detected, deleting the prohibition code from the memory of the flag address.

At this time, in determining whether the variable area is for the waste space recovery, it is determined whether the prohibition code is stored in the flag address, and the data storage space recovery step is performed only when the prohibition code is not stored in the flag address. It is preferable to carry out.

The memory data storage space management method of the present invention is a set of instructions for carrying out this, and can be recorded and produced / distributed on a computer-readable recording medium.

The application program execution apparatus of the present invention using the memory data storage space management method of the present invention includes a microprocessor operating by a set program and one or more memories for storing data necessary for the execution of the application program, the micro A set of instructions of the application program is stored in any one of a processor and the one or more memories, and in any one of the microprocessor and the one or more memories, a set of instructions for performing the memory data storage space management method of the present invention. Application program execution apparatus characterized in that the stored.

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

Figure 2 is a block diagram showing an application program execution apparatus of an embodiment of the present invention.

As shown in FIG. 2, the apparatus for executing an application of an embodiment of the present invention includes a microprocessor 210 that is operated by a set program, and one or more memories 220 that store data necessary during execution of the application. do.

The memory 220 has a data storage space 260 for storing the necessary data.

The application program may be stored in any one of the microprocessor 210 and the one or more memories 220, and is preferably stored in the application program storage space 250 of the memory.

In one of the microprocessor 210 and the one or more memories 220, an OS storage unit for storing a series of instructions (hereinafter referred to as "operating system" (OS)) for executing the application program ( 230 is formed, and first and second storage units 240 and 245 are formed to store a series of command sets for performing the method of managing memory data storage spaces according to the first and second embodiments of the present invention.

Since the operating system (OS) is embodied in various forms obvious to those skilled in the art, more detailed description is omitted.

The application program may be any set of instructions including instructions that operate using the built-in functions of the microprocessor 210 and access the data storage space 260, the source code of which is the source code. Does not originate from any instructional system (eg C, C ++, Pascal, Java, etc.).

The data storage space 260 stores a value (ie, a variable value in the case of a stack variable and a variable value storage address of the variable in the case of a heap variable) corresponding directly to a variable defined in the application program. A stack 270, a heap for storing a variable value of the variable when the variable defined in the application program is a heap variable, and a set storage space 290 in the data storage space 260. (Hereinafter referred to as "hipslot").

The term "hipslot" is intended to refer to a specific storage space and should not be construed as being limited by the words constituting the term.

An application executing apparatus of an embodiment of the present invention will be clarified in its function by the data storage space management method of the first and second embodiments of the present invention described below.

However, the basic configuration of the application program execution apparatus of the embodiment of the present invention, as a specific example, personal computer, notebook, and personal digital assistant (PDA), as well as schedule management, Since various implementations such as mobile phones that support the execution of specific applications, such as e-mail management, are omitted in detail, the application execution apparatus according to an embodiment of the present invention corresponds to any of these specific embodiments. It is also possible to interpret the application execution device of the present invention to be protected to the extent that includes these specific embodiments.

3 is a block diagram illustrating the interrelationship of data stored in the data storage space 260, FIG. 4 is a flowchart illustrating a data storage space management method according to a first embodiment of the present invention, and FIG. It is a flowchart showing a data storage space management method of the second embodiment.

Hereinafter, a method of managing data storage spaces of the first and second embodiments of the present invention will be described in detail with reference to FIGS. 3, 4, and 5.

4 is a flowchart illustrating a data storage space management method according to a first embodiment of the present invention. More specifically, the data storage space of the memory is more efficiently used for the heap variable definition that may occur during the execution of the application program. The present invention relates to a method of operating a data storage space of a memory to be managed.

In the method of managing data storage space according to the first embodiment of the present invention, when a command for defining a heap variable (hereinafter, a "heap variable definition command" is detected (S405)) in the course of executing an application program, as shown in FIG. 4. In operation S410, a first address corresponding to the heap variable (hereinafter, referred to as a "heap variable address") data is stored at a specific address of the stack 270.

The heap variable definition command is available in various forms and is practically implemented. For example, in the case of an instruction originating in C ++, the originating source code may be written in the form of "Object * objVar = new Object ();", so that the heap variable definition instruction is in this form. Written machine code can be compiled machine code.

The heap variable address may be address data for storing a variable value of the heap variable in the heap 280.

By this process (S410), as shown in FIG. 3, the first storage space 271 of the stack 270 includes a variable value storage space 286 of a heap variable (eg, objVar for the source code of the above type). ) 'S address (HeapVar1) will be saved.

After storing the heap variable address (S410), a third address (hereinafter referred to as "heap slot address") is stored in the heap storage area of the second address (hereinafter referred to as "heap slot pointer address") calculated from the heap variable address. Save data (S420).

More specifically, the heap slot pointer address is calculated as a data region preceding the heap variable address. That is, it is intended to store a specific address as a header of the variable value storage space of the defined heap variable, thereby simplifying the data storage system in the heap 280. The one data area depends on the number of addresses given to one data. For example, 8 bytes for a 64-bit computer and 4 bytes for a 32-bit computer. byte).

The heap slot address may be any value as long as it is an address capable of freely replacing the stored value in the data storage space 260 of the memory. However, it is preferable that the address is sequentially calculated in the hip slot 290 arbitrarily partitioned in the data storage space 260.

By this process (S420), as shown in FIG. 3, the address of the first storage space 291 of the hip slot 290 is stored in the first storage space 281 of the heap 280, An area for storing the variable value of the heap variable is secured in the first data space 286 of 280.

After storing the heap slot address (S420), a reference value satisfying the heap slot pointer address and a set condition is stored in the data storage space 291 of the hip slot address (S430).

The set condition may be any condition. For example, the reference value may be the same value as the heap slot pointer address. That is, the heap slot pointer address value is stored in the first storage space 291 of the hip slot 290.

As another preferred example of the set condition, the reference value may be a predetermined constant value.

When such processes S410 to S430 are repeated, it is apparent that a reference relationship between the stack 270, the heap 280, and the data storage space of the heap slot 290 is formed as shown in FIG. 3. .

In addition to the above process (S410 ~ S430), the data storage space management method of the first embodiment of the present invention, the prohibition command and the prohibition command to instruct not to waste space recovery for the defined / defined heap variable Add a configuration to make the unrestricted command available to the application, instructing it to abort the action.

To this end, in the case where the inhibit instruction is detected (S435), a predetermined code (hereinafter referred to as a "prohibition code") is stored in a memory of a fourth address (hereinafter referred to as "flag address") calculated from the heap slot address. When the inhibit release command is detected (S440), the prohibited code is removed from the memory of the flag address (S450).

The prohibition command and the prohibition command may be set to any command by those skilled in the art, and the prohibition code may be set to any code by those skilled in the art.

The flag address may be an address of any storage space that can freely replace the stored value in the data storage space 260, but may preferably be an address adjacent to the heap slot 290.

The memory data storage space management method of the second embodiment using the memory data storage space management method of the first embodiment of the present invention will be described with reference to FIGS. 3 and 5.

5 is a flowchart illustrating a data storage space management method according to a second embodiment of the present invention. More specifically, the data storage space management method according to the first embodiment may be utilized in parallel with the execution of the application program. The present invention relates to a process for determining a variable region for memory waste space recovery that can be performed sequentially.

Since the data storage space management method of the second embodiment of the present invention described below is performed in pairs based on the method of the first embodiment described above, the terms defined in the description of the first embodiment are used in the same meaning.

As shown in FIG. 5, in the data storage space management method of the second embodiment, first, a value stored in the stack (hereinafter referred to as a “stack value”) is extracted (S510).

At this time, as an example, referring to FIG. 3, an address HeapVar1 stored in the first storage space 271 of the stack 270 is extracted as a stack value.

If the stack value relates to a variable value storage address of the heap variable, the stack value is extracted from the heap variable address stored by the method of the first embodiment.

Accordingly, the heap slot pointer address is calculated by assuming that the stack value thus extracted is the heap variable address described in the method of the first embodiment (S520).

That is, the heap slot pointer address is calculated to be one data region preceding the stack value. Accordingly, the address of the first storage space 281 in the heap 280 is calculated with reference to FIG. 3.

A value stored in the calculated heap slot pointer address (hereinafter referred to as a "pointer value") is extracted (S530). Therefore, a value stored in the first storage space 281 in the heap 280, that is, an address of the first storage space 291 of the heap slot 290 is extracted as a pointer value.

If the stack value is for a variable storage address of a heap variable, the pointer value points to a heap slot address. Therefore, assuming that the pointer value is a heap slot address, the value stored at the address (hereinafter referred to as "reference value") It is extracted (S540). That is, the value stored in the first storage space 291 of the hip slot 290 is extracted as a reference value.

By determining whether the reference value extracted by the above process satisfies the set condition (S550), it may be determined whether the value stored in the heap variable address indicated by the stack value is related to the variable value of the heap variable.

The set condition is set equal to the condition set for the reference value in step S430 of the data storage space management method of the first embodiment. That is, it may be determined whether the reference value is the same as the hipslot pointer address, and as another preferred example, it may be determined whether the reference value is equal to a constant value set in the method of the first embodiment.

When the reference value satisfies the set condition, it is determined whether the storage space 286 having the stack value as an address, preferably, the number of times the storage space 281 of the hip slot pointer address is recovered (S570). .

The recovery availability determination (S570) can be determined by any process deemed desirable by those skilled in the art, the details thereof will be omitted to those skilled in the art will be omitted.

By performing these processes (S510 to S570) with respect to all data in the stack (S580), it is possible to efficiently manage the waste space in the heap 280.

If the data stored in the stack 270 is not the variable value storage address of the heap variable, that is, for example, the variable value of the stack variable, the variable value is the address data. When the reference value is extracted and the reference value is not recognized, the reference value does not satisfy the set condition.

Therefore, when n data are stored in the stack 270, the determination step required to determine whether the waste space is to be recovered is a total of "1 * n", which is more than that of m * n according to the prior art. It can be seen that the process is significantly reduced.

In addition to the above-described processes (S510 to S570), the more preferred method for managing the data storage space of the second embodiment determines whether the prohibition code is stored in the flag address described in the first embodiment (S560). Only when the prohibition code is stored in the prohibition code determination step (S560), it is determined whether the variable value storage space 282 of the corresponding heap variable is recovered (S570).

By this additional process (S560), it is possible to specify in the application program not to perform the waste space recovery process for a particular heap variable in the waste space recovery process that can proceed in parallel with the execution of the application program in general. .

The memory data storage space management methods according to the first and second embodiments of the present invention may be distributed and stored individually or integrally in a computer-readable recording medium as a set of instructions for performing the same.

As mentioned above, although the preferred embodiment of the memory data storage space management method, the recording medium recording the method, and the application program execution apparatus using the method have been described, the present invention is not limited to the above embodiment. It includes all the changes from the embodiment of the invention which is easily changed by those skilled in the art to which the invention belongs and is considered equivalent.

According to the embodiment of the present invention, it is possible to reduce the time required for the determination of the closed space of the memory, and thus to improve the driving speed of other programs performed while the memory data storage space management method of the embodiment of the present invention is performed. .

In addition, since the data storage space management method of the embodiment of the present invention is calculated based on the memory address data, it is possible to minimize the driving time of the microprocessor required for the operation.

1 is a view for explaining a conventional closed space discrimination method.

Figure 2 is a block diagram showing an application program execution apparatus of an embodiment of the present invention.

3 is a block diagram showing the interrelationships of data stored in a data storage space in the data storage space management method of the embodiment of the present invention.

4 is a flowchart illustrating a data storage space management method according to a first embodiment of the present invention.

5 is a flowchart illustrating a data storage space management method according to a second embodiment of the present invention.

Claims (9)

A method of managing memory data storage space of an apparatus for executing an application program including a processor, the processor comprising: When the heap variable definition command is detected, storing a heap variable address corresponding to the heap variable at a specific address of the stack; Storing a heap slot address in a heap area of a heap slot pointer address calculated from the heap variable address; And And storing a reference value that satisfies a set condition in a memory of the heap slot address. The processor of claim 1, wherein the processor comprises: Calculating a heap slot pointer address using the value stored in the stack as the heap variable address, and extracting a reference value stored at an address indicated by a value stored in the calculated heap slot pointer address; Determining whether the reference value satisfies the set condition; And And retrieving a variable value storage space of a heap variable whose address is a value stored in the stack when the reference value satisfies the set condition. In claim 2, And the heap slot pointer address is calculated as a value preceding one data area than the heap variable address. In claim 2, And the set condition is a condition equal to the heap slot pointer address. In claim 2, The set condition is a condition that the predetermined value is a memory data storage space management method. The processor of claim 2, wherein the processor comprises: Storing a predetermined prohibition code in a memory of a flag address calculated from the heap slot address when detecting a prohibition instruction indicating not to perform a closed space recovery with respect to the heap variable defined by the heap variable definition instruction; ; And And deleting the prohibition code from the memory of the flag address when detecting a setting command corresponding to the prohibition command. In claim 6, The processor further determines whether the inhibit code is stored in the flag address, And the data storage space retrieval step is performed only when the prohibition code is not stored in the flag address. A non-transitory computer-readable recording medium having recorded thereon a set of instructions for carrying out the method of claim 1. A device that runs an application. A microprocessor operated by a configured program and At least one memory for storing data necessary during the execution of the application program, The instruction set of the application program is stored in any one of the microprocessor and the one or more memories, Apparatus as claimed in claim 1, wherein at least one of the microprocessor and the one or more memories stores a set of instructions for performing the method of any one of claims 1 to 7.