KR101391957B1 - Method for scheduling resource block in wireless communicatoin system and apparatus thereof - Google Patents

Abstract

An efficient memory management method including a memory allocation method and a release method is disclosed.
The method includes the steps of initializing an entire memory block to be allocated to an application program, Allocating a block requested to be allocated from an application program in the entire memory block and recovering a block requested to be released from the application program in the entire memory block; And returning the entire memory block, wherein the head index of the entire memory block, where the head index is the next memory block located at the end of the entire memory block among the memory blocks allocated among the entire memory blocks, And a tail index, wherein the tail index indicates a position of a memory block located at the beginning of the entire memory block among the memory blocks allocated among the entire memory blocks, The index and the tail index are incremented from 0 and set to 0 at the end of the entire memory block.

Description

BACKGROUND OF THE INVENTION 1. Field of the Invention [0001] The present invention relates to a memory management method,

The present invention relates to an efficient memory management method including a memory allocation method and a release method.

The image processing system processes the image data according to the purpose. In this process, a memory for storing the image data is required.

In general, the memory to process the data is provided by the memory allocator built in the programming language (memory allocation), and is returned to the allocator when the necessary processing is completed (memory release). In this case, due to the characteristics of the image processing system, the above process, that is, the process of allocating and releasing the memory, is continuously and frequently performed. Here, the fragmentation problem refers to the phenomenon that the operating system consumes more memory and CPU resources than the amount of memory required by the system if the size of the allocated memory block is irregular.

To solve this problem, there is a well-known memory pool. The memory pool is designed to avoid the fragmentation phenomenon by preliminarily setting the size of a memory block to be used in a predetermined size.

However, there is a problem that it is very difficult to apply the memory pool because the size of the image data varies depending on the image quality / resolution / compression method and the like.

Therefore, there is a need for a method for efficient memory management by a memory allocator built in a programming language in an image processing system having a characteristic that memory allocation and release are relatively sequential.

An object of the present invention is to provide an efficient memory management method including a memory allocation method and a cancellation method which can easily predict a real capacity of a memory by solving the fragmentation phenomenon, and efficiently use memory resources and CPU resources.

According to an aspect of the present invention,

CLAIMS What is claimed is: 1. A method for a memory allocator to manage memory, comprising: initializing an entire memory block to be allocated to an application program; Allocating a block requested to be allocated from an application program in the entire memory block and recovering a block requested to be released from the application program in the entire memory block; And returning the entire memory block, wherein the head index of the entire memory block, where the head index is the next memory block located at the end of the entire memory block among the memory blocks allocated among the entire memory blocks, And a tail index, wherein the tail index indicates a position of a memory block located at the beginning of the entire memory block among the memory blocks allocated among the entire memory blocks, The index and the tail index are set to the start position again from the end position of the entire memory block, starting from the start position of the entire memory block.

The initializing may include: allocating the entire memory block from a programming language or an operating system; And setting the head index and the tail index to the start position.

In addition, the memory allocator may allocate meta information when the block allocation is requested.

In addition, the meta information includes a busy mark indicating that the block is allocated and information indicating the size of the allocated memory block.

Also, the in-use mark is written in the first byte of the allocated memory block and is "* ".

In addition, when the in-use mark is written as '0', it indicates that the corresponding memory block is recovered.

The information indicating the size of the allocated memory block among the meta information is recorded at the beginning and the end of the allocated memory block, respectively.

In addition, if it is difficult to allocate an allocation allowable amount (hereinafter referred to as "end spare capacity") from the head index to the end of the entire memory block to the allocation requested block, And allocates the memory block from the beginning of the entire memory block.

In addition, in the recovering step in the entire memory block, when the memory block at the position before the head index is retrieved, the head index is moved to point to the memory block from which the head index is retrieved.

In addition, when there are a plurality of recovered memory blocks before the head index, the head index is moved to point to the memory block at the beginning of the plurality of retrieved memory blocks.

When the memory block of the tail index is retrieved in the step of recovering in the entire memory block, the tail index is moved to point to a memory block in the next position of the memory block in which the tail index is retrieved.

If there are a plurality of recovered memory blocks after the tail index, the tail index is moved to point to a memory block next to the memory block at the end of the plurality of retrieved memory blocks .

According to another aspect of the present invention,

A method for allocating memory in a memory allocator, the memory allocator allocating a total memory block to be allocated to an application program to a head index, wherein a head index is allocated at the end of the entire memory block among allocated memory blocks in the entire memory block Wherein the tail index indicates a position of a memory block located at an initial portion of the entire memory block among the memory blocks allocated among the entire memory blocks, (Hereinafter referred to as "end spare capacity") from the head index to the end of the entire memory block with respect to a block requested to be allocated from an application program; Allocating a memory block of the requested block size to the position of the head index when the allocation of the block requested by the allocation is possible to the end margin amount; And recovering the end margin if the allocation of the block requested by the allocation to the end margin is impossible.

Herein, in the step of recovering the end margin amount, when the remaining margin amount excluding the end margin amount in the total margin amount of the entire memory blocks becomes an amount capable of allocating the allocation requested block, the end margin amount is recovered .

In the step of recovering the end margin amount, after the end margin amount recovery, the head index is moved to point to the first memory block of the entire memory block, and the position of the moved head index is shifted And allocating a memory block.

According to still another aspect of the present invention,

CLAIMS What is claimed is: 1. A method for releasing memory allocated to an application by a memory allocator, the memory allocator comprising: a head index for allocating an entire memory block to be allocated to an application program, And a tail index, wherein the tail index indicates a position of a memory block located at the beginning of the entire memory block among the memory blocks allocated among the entire memory blocks, And if the memory block is requested to be released from the application program, recovering the memory block requested to be released; Moving the head index so as to indicate a memory block recovered in the case where the recovered memory block is a memory block in a previous position of the head index; And moving the tail index to point to a memory block at a next position of the memory block retrieved from the tail index if the memory block recovered in the step is a memory block of the tail index.

Here, in the step of moving the head index, if there are a plurality of recovered memory blocks before the head index, the head index is moved so as to point to the memory block at the beginning of the plurality of recovered memory blocks .

In the step of moving the tail indices, if there are a plurality of recovered memory blocks after the tail index, the tail index is moved to the memory block at a position next to the memory block at the end of the plurality of recovered memory blocks. And the index is moved.

According to the present invention, fragmentation phenomenon is solved by using the sequential characteristics when the memory allocation and release are relatively sequential like the image processing system, that is, when the memory is allocated and released after a certain time.

In addition, the fragmentation phenomenon is solved, the real capacity of the memory can be predicted easily, and memory resources and CPU resources can be efficiently used.

1 is a block diagram conceptually illustrating an annular buffer type memory to be used by a memory allocator according to an embodiment of the present invention.
2 is a flowchart of a memory management method according to an embodiment of the present invention.
3 is a specific flowchart of the memory initialization step shown in FIG.
FIG. 4 is a flowchart specifically illustrating a memory allocation step in the memory allocation and release step shown in FIG. 2. FIG.
5 is a diagram illustrating a state of a memory block in operation according to an embodiment of the present invention.
FIG. 6A shows a memory before allocating a memory block according to an embodiment of the present invention, and FIG. 6B shows a memory after allocating a memory block of 300 bytes.
FIG. 7A is a diagram showing end use amounts in an entire memory block according to an embodiment of the present invention, and FIG. 7B is a diagram showing a memory after withdrawing end use amounts.
FIG. 8 is a flowchart specifically illustrating a memory release step in the memory allocation and release step shown in FIG. 2. FIG.
9A is a diagram illustrating a memory including a block allocated with 300 bytes according to an embodiment of the present invention, and FIG. 9B is a diagram showing a memory after releasing an allocated block of 300 bytes .
FIG. 10A is a view showing that a memory block at a position before a head index in the embodiment of the present invention is a memory block to be retrieved, FIG. 10B is a view showing a state in which a memory block at a position before a head index is retrieved , and (c) are views showing the movement of the head index position due to the number of memory blocks in the position before the head index.
FIG. 11A is a diagram showing a memory block of a tail index in the embodiment of the present invention as a memory block to be retrieved, FIG. 11B is a diagram showing a state in which memory blocks of a tail index are retrieved, Is a diagram showing that the tail index position is shifted due to the number of memory blocks of the tail index.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings so that those skilled in the art can easily carry out the present invention. The present invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. In order to clearly illustrate the present invention, parts not related to the description are omitted, and similar parts are denoted by like reference characters throughout the specification.

Throughout the specification, when an element is referred to as "comprising ", it means that it can include other elements as well, without excluding other elements unless specifically stated otherwise. Also, the terms " part, "" module," and " module ", etc. in the specification mean a unit for processing at least one function or operation and may be implemented by hardware or software or a combination of hardware and software have.

Now, a memory management method according to an embodiment of the present invention will be described in detail with reference to the drawings.

First, the memory used by the memory allocator in the embodiment of the present invention is managed in the form of a circular buffer, as shown in FIG. That is, if the size of the entire memory block to be used by the memory allocator is N bytes, the entire memory block of N bytes is managed using two pointers, that is, a head index and a tail index. Here, the head index points to the front of the memory in use, and the tail index points to the end of the memory in use. That is, from the head index to the end of the entire memory block, and from the tail index to the beginning of the entire memory block, there is no memory block in use. Thus, the tail index can not point to memory ahead of the head index. If the size of the entire memory block is N bytes, the head index and the tail index may have a value from 0 to N-1. If the size of the memory block is N-1, do.

2 is a flowchart of a memory management method according to an embodiment of the present invention.

Referring to FIG. 2, when the image processing system is activated, the memory allocator initializes the memory when all memory blocks to be used by the programming language or the operating system are allocated (S100).

Thereafter, the memory allocator allocates and releases the memory blocks according to the request from the application program for the entire memory blocks to perform management for the memory (S200).

The memory allocator then returns the entire memory block being used at the end of the programming language or operating system (S300).

3 is a specific flowchart of the memory initialization step shown in FIG.

Referring to FIG. 3, when the entire memory block to be used by the memory allocator is allocated from the programming language or the operating system (S110), the memory allocator sets the head index and the tail index used for managing the allocated memory blocks to 0, (S120).

Meanwhile, the memory management method of the memory allocator according to the embodiment of the present invention can be expressed in a programming language, for example, a C programming language.

3, the basic parameters necessary for the memory allocator to initialize the memory are as follows.

Here, mq_memoryq is a variable to be allocated and stored in the C programming language for the entire memory block to be used by the memory allocator, and mq_capacity is the size of the entire memory block to be used by the memory allocator.

mq_head and mq_tail represent the above head index and tail index.

mq_size is a variable used to calculate the memory allocator usage and free space.

mq_mark and mq_mark_int are markers that write to allocated memory blocks.

In the embodiment of the present invention, information on each block is recorded at the start and end of each memory block. This information is called meta information. The meta information includes an in-use indicator indicating that the application program is allocated and used, for example, '*' and the size of each memory block. In the meta information, a total of 8 bytes are used, which is the sum of 4 bytes at the beginning of the memory block and 4 bytes at the end. Therefore, the size of each memory block is the size of the memory block requested by the application program plus 8 bytes for recording the meta information. In the above, _metasize is a constant 8 which is the size of meta information, and _metaoffset is a constant 4 which is half of _metasize.

The memory allocator must be initialized once the application is started, and this initialization process can be expressed in the C programming language as follows.

A conceptual view of the memory after performing this initialization is shown in FIG. The head index and the tail index are initialized to zero, which means start, and the memory allocator obtains N bytes of memory blocks to be used by the application from the C programming language.

After that, the application program requests the memory allocator to allocate and release the memory block from time to time while performing the operation.

FIG. 4 is a flowchart specifically illustrating a memory allocation step in the memory allocation and release step shown in FIG. 2. FIG.

Referring to FIG. 4, the memory allocator determines whether the block size requested by the application program is equal to or greater than the available memory space (S210). That is, it is judged whether or not there is a memory block having an allowable amount of allocation among the memory blocks.

If it is determined in step S210 that the requested block size is equal to or larger than the amount of memory available, the memory allocator can not allocate memory.

However, if the block size requested in the above step S210 is smaller than the memory allowance, the memory allocator can allocate the remaining memory blocks from the memory block indicated by the head index to the end of the entire memory block Quot; end margin amount ") (S212). That is, the memory allocator adds the block size requested to be allocated to the head index, and determines whether the value obtained by adding the meta information size to the head index is greater than the end of the entire memory block.

If the sum of the head index, the allocation requested block size, and the meta information size is not larger than the end of the entire memory block, that is, the end allocation, the memory allocator starts from the memory block indicated by the head index, The block is allocated to the application program (S213).

Hereinafter, the memory allocation in step S213 will be described with reference to the drawings.

5 is a diagram showing a state of a memory block in operation.

Referring to FIG. 5, a block filled with an inner program is a block allocated to an application program. Otherwise, a block in which an inner program is empty is an unallocated block that is not allocated to an application program. . Here, the released block has the same meaning as the block retrieved by the memory allocator.

FIG. 6 is an enlarged view of a portion indicated by a circle in FIG. 5, that is, a memory block indicated by the head index.

Referring to FIG. 6A, the last block allocated to the application program among the memory blocks is a block to which 400 bytes are allocated, and the head index indicates the next memory block of the memory block.

In this state, when a request for allocation of a memory block of, for example, 292 bytes is received from an application program, a memory block of 300 bytes including the meta information size 8 bytes added to the requested 292 bytes as shown in FIG. 6 (b) . In this case, since the memory block after the head index can be allocated to the memory block of 300 bytes which is added with the meta information size 8 to the 292 bytes which are requested to be allocated, the allocation process is performed as described above.

Referring to FIG. 6 (b), a busy mark, i.e., '*', is assigned to the first byte of the allocated block to indicate that it is in use, and 300 bytes, which is the size of the memory block, is written in 0x012c, which is hexadecimal . The size of the block, 0x0012c, is also written in the last 4 bytes of the allocated block.

Thereafter, the head index is increased by the allocated 300 bytes to indicate the memory block next to the allocated 300 bytes of the memory block (S214). Then, the memory allocator returns the block position allocated to the application program so that the application program can perform the operation using the allocated memory (S215).

In this manner, the memory allocation in the case where the allocation can be made to the end margin amount is completed.

If the sum of the head index, the block size requested by the allocation request, and the meta information size is larger than the end of the entire memory block, that is, the allocation can not be performed as the end spare capacity, the memory allocator excludes the end spare capacity And determines whether or not the amount of spare space in the entire memory block is an amount of spare space for allocating the allocation requested block (S216). To this end, the memory allocator determines whether the value obtained by adding the end margin amount and the block size requested to be allocated is equal to or greater than the margin amount of the memory.

If the sum of the end margin amount and the allocation requested block size is equal to or more than the total margin amount of the memory, that is, the margin amount in the entire memory block is not sufficient to allocate the allocated allocation block, (S211).

However, if it is determined in step S216 that the value obtained by adding the end margin amount and the allocation requested block size is less than the total margin amount of the memory, that is, excluding the end margin amount, If there is a spare capacity, the memory allocator retrieves a memory block of an end margin amount that can not allocate the allocation requested block (S217), and sets the head index to 0 (S218). That is, after the memory block remaining from the head index position to the end of the entire memory block is not allocated, the head index is set to 0 for allocation from the beginning of the entire memory block.

Hereinafter, the memory number in the step S217 will be described with reference to the drawings.

7 is a diagram illustrating a memory state when allocation is requested at the end of an entire memory block in the embodiment of the present invention.

Referring to (a) of FIG. 7, 20 bytes of the end margin that can be allocated at the end of the entire memory block are left, and the head index indicates the corresponding position. On the other hand, at the shortest end of the entire memory block, the memory block having the lowest meta information size is always set, that is, an 8-byte memory block.

Therefore, if an application requests 4 bytes or less of memory blocks, 8 to 12 bytes of memory blocks can be allocated and one 8-byte recovered memory block can be filled at the end, since more than 4 bytes can be allocated. If there is a block allocation request, allocation to the end redundancy amount becomes impossible. Thus, the memory allocator fills the remaining 20 bytes with the retrieved memory block as shown in Figure 7 (b). The head index is set to zero.

Since the head index is 0 and the remaining spare memory block can be allocated, the memory allocator allocates the allocation requested block to the application program starting from the memory block indicated by the head index (S213), and allocates the head index (S214), and returns the block position allocated to the application program (S215).

As described above, in the embodiment of the present invention, when the terminal usage amount is not enough to allocate the blocks requested to be allocated at the head position, the terminal usage amount is recovered and the fragmentation problem is reduced.

The following is an example of the memory allocation method shown in FIG. 4 expressed in C programming language.

FIG. 8 is a flowchart specifically illustrating a memory release step in the memory allocation and release step shown in FIG. 2. FIG.

Referring to FIG. 8, in step S220, the memory allocator determines whether the usage amount is greater than 0 in order to check whether there is an active memory allocated to an application program.

If the used amount is 0 in step S220, the memory allocator can not perform the memory release because there is no memory in use, so that the memory allocator notifies the application program of the release failure (S221).

If it is determined in step S220 that the amount of usage is greater than 0 and the memory is allocated to the application program and there is an in-use memory, it is determined whether the memory block allocated by the application program is a memory block allocated in operation S222.

If the memory block requested to be released is not a memory block to which the allocated memory block is allocated, that is, if the memory block is not allocated, the memory allocator notifies the application program of the release failure (S221).

However, if the released memory block is the allocated memory block, the memory allocator reclaims the memory block requested to be released (S223).

Hereinafter, the memory recall in step S223 will be described with reference to the drawings.

9 is a diagram showing a memory state including blocks requested to be released in an embodiment of the present invention.

Referring to FIG. 9A, the memory block of 300 bytes allocated to the application program in the entire memory block is requested to be released from the application program in FIG. 6B.

Since the memory allocator is a memory block allocated to the application program by the memory block requested to be released, the memory allocator is recovered by writing 0 indicating that the first byte of the memory block requested to be released has been recovered as shown in FIG. 9 (b) And completes the releasing process for the memory block.

Here, since the memory block requested to be released is located between the in-use memory blocks, there is no variation in the head index and the tail index.

Thereafter, it is judged whether or not the memory block allocated to the application program is in use and the memory block recovered in the step S223 is a memory block before the head index (S224).

If the used memory block is larger than 0 and the recovered memory block is a memory block located before the head index, the value of the head index is replaced to indicate the memory block at the previous position (S225). Here, steps S224 and S225 are repeated until the memory block at the position before the head index is not the recovered memory block, that is, until it is the in-use memory block. This is illustrated in FIG.

FIG. 10A is a view showing that a memory block at a position before a head index in the embodiment of the present invention is a memory block to be retrieved, FIG. 10B is a view showing a state in which a memory block at a position before a head index is retrieved , and (c) are views showing the movement of the head index position due to the number of memory blocks in the position before the head index. Referring to FIG. 10B, a memory block at a position before the head index is retrieved, so that a plurality of previous memory blocks become consecutively recovered memory blocks. Therefore, by repeating the above steps (S224, S225), the head index passes all the memory blocks continuously retrieved and is moved to point to the position in front of the memory block in use as shown in FIG. 10 (c) The allocated memory block is incorporated into the allocable usage amount.

Thus, if the memory block at the position before the head index is the recovered memory block, the memory fragmentation is reduced by moving the head index so that the memory block at the previous position becomes the allocatable memory block.

Next, if the amount of memory used in step S224 is less than or equal to 0, but the memory block in the previous position is not the recovered memory block, the memory allocator allocates 0 It is determined whether the memory block having the larger tail index position is the recovered memory block (S226).

If there is a usage and the memory block of the head index is the retrieved memory block, the memory allocator replaces the tail index with the next memory block (S227). Here, the steps (S226, S226) are repeated until the memory block of the tail index is not the recovered memory block, that is, until it is the in-use memory block. This is illustrated by the accompanying Fig.

FIG. 11A is a diagram showing a memory block of a tail index in the embodiment of the present invention as a memory block to be retrieved, FIG. 11B is a diagram showing a state in which memory blocks of a tail index are retrieved, Is a diagram showing that the tail index position is shifted due to the number of memory blocks of the tail index. Referring to FIG. 11B, the memory block of the tail index is retrieved, and thus the memory blocks preceding the several memory blocks are consecutively recovered. 11C, the tail index is shifted to point to the memory block in use by passing all the memory blocks continuously recovered, and thus the memory block is continuously recovered. As a result, Is incorporated into the allocable usage amount.

In this manner, if the memory block of the tail index is a retrieved memory block, memory fragmentation is reduced by moving the tail index so that the next memory block is an allocatable memory block.

The following is an example of the memory heap method shown in FIG. 8 expressed in C programming language.

If little-endian is used in the above, it should be replaced with * (cptr-1) = 0.

In the above, the mq_notuse (index) can be simply implemented as follows.

For big-endian:! * (Mq_memoryq + index)

For Little Endian:! * (Mq_memoryq + index +3)

In the above, mq_ndsize (index) can be implemented as follows.

int * iptr = (int *) (mq_memoryq + index);

return * iptr &0x00ffffff;

The functions mq_prev (index) and mq_next (index) can be implemented as follows.

In the above description, the memory allocation and release method in the embodiment of the present invention has been described using the C programming language. However, the present invention is not limited to this example, and it can be realized by other methods, Can also be implemented.

While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments, It belongs to the scope of right.

Claims (15)

In a method for a memory allocator to manage memory,
Initializing an entire memory block to be allocated to an application program;
Allocating a block requested to be allocated from an application program in the entire memory block and recovering a block requested to be released from the application program in the entire memory block; And
And returning the entire memory block,
Wherein the head index refers to the position of the next block of the memory block located at the end of the entire memory block among the memory blocks allocated among the entire memory blocks and a tail index, Wherein the head index and the tail index correspond to a position of a memory block located at the beginning of the entire memory block among the memory blocks allocated among the entire memory blocks, And is set to the start position again from the end position of the entire memory block,
Wherein the head index is changed when the memory block to be recovered is a memory block at a previous position of the memory block of the head index and the tail index is changed when the memory block is the memory block of the tail index, The head index and the tail index are not changed when the memory block is not the memory block at the previous position of the memory block of the head index and the memory block of the tail index
Lt; / RTI > The method according to claim 1,
Wherein the initializing comprises:
Allocating the entire memory block from a programming language or an operating system; And
Setting the head index and the tail index to the start position
/ RTI > The method according to claim 1,
Wherein the memory allocator allocates the meta information when allocating the requested block. The method of claim 3,
Wherein the meta information includes an in-use indicator indicating the allocated block and information indicating a size of the allocated memory block. 5. The method of claim 4,
Wherein the in-use indicator is written in the first byte of the allocated memory block and is "* ". 6. The method of claim 5,
And when the in-use mark is written as '0', it indicates that the corresponding memory block has been retrieved. 5. The method of claim 4,
Wherein the information indicating the size of the allocated memory block among the meta information is recorded at the beginning and the end of the allocated memory block, respectively. The method according to claim 1,
(Hereinafter referred to as "end margin amount") from the head index to the end of the entire memory block with respect to the allocation requested block, And allocating the memory area from the beginning of the block. The method according to claim 1,
In the step of recovering in the entire memory block,
And when the memory block at a position before the head index is retrieved, the head index is moved to point to the memory block from which the head index is retrieved. 10. The method of claim 9,
Wherein the head index is moved to point to a memory block in a first portion of the plurality of retrieved memory blocks if a plurality of retrieved memory blocks exist prior to the head index. The method according to claim 1,
In the step of recovering in the entire memory block,
Wherein when the memory block of the tail index is retrieved, the tail index is moved to point to the memory block at the next position of the memory block from which the tail index is retrieved. 12. The method of claim 11,
And if the number of recovered memory blocks after the tail index exists, the tail index is moved to point to a memory block at a position next to the memory block at the end of the plurality of recovered memory blocks. Way. delete delete delete

Images