KR100941423B1 - Method For Allocating a Page of a Memory and a Computer-readable Recording Medium For Program Which Accomplishes Thereof - Google Patents

Abstract

A page allocation method of a memory according to an embodiment of the present invention, which allocates a page of memory as window information having update information on a logical page, includes a plurality of blocks configured as physical pages. A page allocation method of a memory, the method comprising: dividing the plurality of blocks into a first block and a second block; Calculating an update number of the specific logical page when receiving a request for updating a specific logical page; And for a specific logical page updated according to the update request, determining whether to allocate a physical page of the second block according to the calculated update number.

Logical page, physical page, update

Description

Method for Allocating a Page of a Memory and a Computer-readable Recording Medium For Program Which Accomplishes Thereof}

The present invention relates to a method of allocating a page of a memory and a computer-readable recording medium having a program for performing the same. More specifically, the method of allocating a page of a memory as window information having update information on a logical page and the same And a recording medium having recorded thereon a program.

In general, NAND flash memories are divided into a plurality of blocks and a plurality of pages constituting the blocks. The file may be stored in a plurality of pages, one file may exist in a plurality of blocks, or a plurality of files may be stored in one block.

1 is a block 106 composed of 32 pages 104, each page 104 having a 512 byte data area and a 16 byte spare area. Has The entire NAND flash memory 102 is made up of 4096 blocks 106 and each block 106 is made up of 32 528-byte pages 104 and thus has a size of 66 megabytes (528 megabits). .

However, NAND flash memory has the following limitations that are distinguished from existing storage media. First, in order to overwrite, delete operation must be preceded. Second, delete operations are different from read and write operations. Third, the erase operation is slower and consumes more power than other operations. Fourth, the number of erase operations is limited for each block.

To overcome the above limitations, the Log-structured File System (LFS) uses an external update technique that transforms the overwrite operation into an additional operation. This writes the modified data to another free area and invalidates the existing data, eliminating the delete operation that must be preceded by the overwrite. However, block cleaning is required to recover invalidated data generated in the process and convert the data into a rewritable state. Reducing the cost and the number of block cleaning greatly affects the performance of the file system.

Block cleaning is performed by first selecting a victim block to be deleted, copying valid data of the block to another block, and then deleting the block.

However, in the process of allocating another physical page for the updated logical page and invalidating the existing physical page, the general method allocates the physical pages sequentially so that the valid and invalid pages are spread over the entire memory. Therefore, if a block containing invalid pages is selected as a victim block during block cleaning, there is a problem in that a read and write time for block cleaning is large.

In addition, if a block having a large number of valid pages is selected as a victim block during block cleaning, there is a problem that fewer physical pages can be recovered and used by block cleaning, thereby increasing the number of block deletions.

SUMMARY OF THE INVENTION The present invention has been made in view of the above-described problem, and an object of the present invention is to provide a method of allocating a physical page to an updated logical page so as to provide a low cost memory page allocation method for block cleaning.

Another object of the present invention is to provide a method of allocating a page of a memory having a large number of physical pages recovered after block cleaning and having a low number of block deletions.

According to an aspect of the present invention, there is provided a method of allocating a page of a memory, the method comprising: a plurality of blocks configured as physical pages, wherein the plurality of blocks are allocated. Dividing the into a first block and a second block; Calculating an update number of the specific logical page when receiving a request for updating a specific logical page; And for a specific logical page updated according to the update request, determining whether to allocate a physical page of the second block according to the calculated update number.

As described above, according to the present invention, by allocating hot pages that are frequently updated to other blocks, page allocation of a memory capable of reducing the overall block cleaning cost by reducing the effective pages of blocks to be deleted at the time of block cleaning as much as possible. It is effective to implement the method.

In addition, according to the present invention, by increasing the number of physical pages that can be used to recover a large number of invalid pages when cleaning the block, another method for implementing a page allocation method of the memory to reduce the number of block deletions and to reduce garbage collection (Garbage Collection) It works.

Before describing the embodiments of the present invention, a general page allocation method, garbage collection, and block cleaning of a flash memory according to modification of a file will be described with reference to FIG. 2. Briefly explain.

2 is a diagram illustrating a state of a memory according to a general page allocation method after file modification. An example is described as a YETFS (Yet Another Flash File System), which is a NAND flash-only file system.

In YAFFS, when a file is first created after the file system is mounted, it is assigned a yaffs_Object to store the file's information in memory and a yaffs_Tnode to store the file's location. The free page is allocated according to the page allocation policy, the actual data is written, and the physical address of the page is recorded in yaffs_Tnode. Therefore, the logical page address of the file is stored in yaffs_Object, and the physical page address is found using the yaffs_Tnode tree.

In addition, the file information of the file size, number of data pages, file creation and modification times is updated to yaffs_Object, and based on the content of the yaffs_ObjectHeader, the free pages are allocated and recorded in the flash memory.

When some of the data in the file is modified, a free page is first allocated, and the modified data is written to the allocated free page. It then makes the page that stored the old data invalid. It searches the Tnode tree by the logical address and updates the physical address of the page where the modified data is stored. Therefore, when some of the data of the file is modified, the page to be updated among the pages constituting the file is changed to an invalid page, and the updated data is stored in the newly allocated free page.

In the memory structure of FIG. 2, there are five blocks including five pages as components, and A files, B files, C files, and D files are stored. Pages A1, A2, and A3 constitute an A file, and in the same manner, the remaining files are organized. A1 202, A2, A3, B1 206, and B2 constitute the first block, and in the same manner, one page column becomes one block, and the remaining blocks are constituted.

When an update request for A1 of the A file is received, the existing A1 is converted into an invalid page A1 202, a new free page is allocated, and the updated data is stored in the valid page A1 204. Similarly, invalid page B1 206 and valid page B1 208 are generated.

However, in FIG. 2, it can be seen that free pages located after D3 are sequentially allocated in the third block for updating A1, B1, and C1. Thus, as the updates to the pages continue, invalid pages such as A1 202 and B1 206 are scattered over the entire area of the flash memory.

As a result, the number of free blocks that can be used decreases. Thus, when there is not enough space to store data, garbage collection is performed to free up space by selecting victim blocks and erasing them by the erase policy.

Securing space by selecting and deleting the sacrificial block is called block cleaning. In FIG. 2, the second block 210 is selected as the sacrificial block for the block cleaning. Hereinafter, referring to FIG. 3, a state of a memory after general block cleaning will be described.

Referring to FIG. 3, the pages of the second block 302 have been cleaned and converted into free pages, and B3 304, B4 306 and C2 308 of the fourth block are the previous second block 210. The data of B3, B4, and C2 included in the) are written and created on the newly allocated free page by block cleaning.

The general page allocation method shown in FIGS. 2 and 3 requires a large cost in block cleaning. That is, three reads and three writes are performed to generate B3 304, B4 306, and C2 308 during the block cleaning of the second block 302, and one block erase time is required. do.

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

4 is a diagram illustrating a state of a memory after a file is modified by the page allocation method according to an exemplary embodiment of the present invention.

As shown, in the allocation method according to an embodiment of the present invention, valid and invalid pages are separated. The separation method is to allocate the corresponding physical pages to the block 402 for the hot page when the logical page is a hot page (H1, A2, A3, A4) with a large number of updates.

Referring to FIG. 4, when the logical pages A1, B1, C1, and D1 of the files A, B, C, and D are frequently updated hot pages, a valid page that is a physical page of A1, B1, C1, and D1 at the time of updating A1 404, B1 406, C1 408 and D1 410 are stored in block 402 for hot pages. In this case, the physical pages of A1, B1, C1, and D1 before being updated are converted to invalid pages A1, B1, C1, and D1.

In this case, if the block 412 of the area where the invalid pages exist is selected as the victim block 412, since the valid pages included in the victim block 412 are relatively few and the invalid pages are many, the same is true through FIGS. 2 and 3. More pages can be retrieved at less cost than in the general case described above. The conventional method at the time of block cleaning has a cost of [3 * (page read time + page write time) + block erase time], while the method according to an embodiment of the present invention is [1 * (page read time + page write). Time) + block deletion time].

FIG. 5 is a diagram illustrating a state of a block cleaning finished after a file is modified using the page allocation method according to an exemplary embodiment of the present invention.

Referring to FIG. 5, all pages of the block cleaning block 502 that have been cleaned are converted to free pages. In addition, A1 of the block 412 selected during block cleaning is allocated the physical page of the block 402 for the hot page, and is stored in the corresponding physical page. Thus, the valid page A1 504 of the fifth block is generated.

As a result, unlike the general case of FIGS. 2 and 3, since only the valid page A1 504 is generated during block cleaning, it can be seen that only one read and one write time are required in addition to the block erase time.

4 and 5, the number of free pages currently available is 11 in the general method and 13 in one embodiment according to the present invention. This is because the proposed scheme has many pages recovered after block cleaning.

Garbage collection is executed when the available area falls below a predefined threshold to ensure free page area. Therefore, in one embodiment of the present invention, since a relatively large number of invalid pages are retrieved and have more areas available, less garbage collection is performed, thereby reducing the number of block deletions.

Therefore, in the present invention, by placing hot pages that are frequently updated in other blocks, the effective pages of blocks to be deleted during block cleaning are reduced as much as possible, thereby reducing the overall block cleaning cost and reducing the number of block deletions.

Meanwhile, in an embodiment of the present invention, in order to determine whether a logical page to be updated is a hot page, a window having a window and a list of windows having update information of the logical page is used. In one embodiment, the window may be created in RAM or in flash memory.

FIG. 6A is a diagram illustrating a window structure used to store update information of a logical page according to an embodiment of the present invention. FIG.

Referring to FIG. 6A, chunkInInode stores a logical page number to be updated, update_cnt stores the number of updates, and Link is used as a link for creating a window list.

FIG. 6B is a diagram illustrating a window list according to an embodiment of the present invention, wherein a window generated while a logical page of a specific file is updated in the order of logical page numbers 3, 4, 6, 8, 1, 18, 14, and 15 Represents a list.

The window list consists of windows less than or equal to the predefined maximum number (MAX_WINDOW_SIZE), one per file. If the number of windows (window size) is the maximum, in order to allocate a window for a new logical page, among the windows with the least update count, the oldest window is selected as the victim window and the new window is added. The window list is initialized when the total sum of the update counts of the windows exceeds the predefined maximum number of times (MAX_TOTAL_UPDATE_CNT).

Referring to FIG. 6B, a window may be divided into a main window 602 generated at the same time as file generation and sub windows 604 and 606 generated when a page is updated and added to the window list.

The subwindows are connected through the windows_head of the main window 602, the number of subwindows is stored in windows_size, and the total number of updates of the sub windows constituting the window list is stored in total_update_cnt. It is used when calculating.

As shown, when a page corresponding to logical page number 3 is updated, a corresponding subwindow 604 is created and linked to the main window 602. The logical page number 3 is stored in the chunkInInode 608 of the sub-window 604, and 1 is stored in the update_cnt 610 because it is updated once.

Next, when the page corresponding to logical page address 4 is updated, a corresponding sub window 606 is generated and linked to the sub window 604 of logical page number 3.

Similarly, the corresponding window is generated for each logical page number 6, 7, 1, and 18 at each update.

In the window list of FIG. 6B, windows_size of the main window 602 is 6, and total_update_cnt is 6.

In addition, the average update count (avg_update_cnt) of the window list is 1 (= total_update_cnt / windows_size).

In one embodiment of the present invention, the window list is used to determine whether the updated logical page is a hot page. If it is determined as a hot page, a physical page of a block for the hot page (hereinafter referred to as a 'hot block') is allocated to the hot page to be updated. In the opposite case, the physical page of the general block is allocated.

For example, if the updated logical page corresponds to the number 3 and the window is already present in the window list, the method of determining whether the page is a hot page is that the update count of the logical page acquired by update_cnt 610 of the logical page to be updated is main. It is compared with the average update count (avg_update_cnt) calculated from the windows_size and total_update_cnt of the window 602. Here, if the comparison result is equal to or greater than the average update count, it is determined as a hot page.

7 is a diagram illustrating movement of a window when a window of a logical page to be updated already exists in the window list according to an embodiment of the present invention.

When the window list of FIG. 6 exists, when an update request for a specific page is received, it is first determined whether a sub-window of the specific page exists in the window list. In FIG. 7, since a request for updating a page corresponding to logical page number 3 is received, a sub window 702 of a page to be updated already exists.

Then, it is determined whether the logical page to be updated is a hot page, and it is determined whether to allocate a physical page of the hot block. However, as described above with reference to FIG. 6, since the average number of updates is 1 and update_cnt of the corresponding sub window 702 is 1, the corresponding page is determined to be a hot page. Thus, the physical page of the hot block is allocated.

Thereafter, update_cnt of the corresponding subwindow 702 is increased by 1 to record 2 (704). The sub window 702 is moved to the latest position 706.

8 is a diagram illustrating a method of adding a new window by an update request when the number of windows that can exist in the window list is the maximum according to an embodiment of the present invention.

FIG. 8 illustrates a window list structure that is changed when pages corresponding to logical page numbers 5, 8, 9, 2, and 15 are sequentially updated in the window list updated in FIG. Hereinafter, it is assumed that the maximum value MAX_WINDOW_SIZE of the preset number of subwindows that can exist is 10.

When the pages corresponding to the logical page numbers 5, 8, 9, and 2 are sequentially updated, the windows of the logical page do not exist in the window list of FIG. 7, so that the corresponding sub-windows 802, 804, 806, and 808 are sequentially placed in the latest positions. Is added.

However, when the sub window 808 corresponding to logical page number 2 is added, the total number of sub windows in the window list is equal to MAX_WINDOW_SIZE (= 10). Therefore, to add a sub window 812 corresponding to logical page number 15 for updating, one sub window must be removed from the window list.

Here, the window 810 in which the update number is the smallest and the information of the logical page updated the longest before is recorded is removed. After subtracting the update count of the window 810 from the total update count of the window, a new window 812 for logical page number 15 is allocated and included in the window list.

9 is a flowchart illustrating a page allocation method of a memory according to an embodiment of the present invention.

First, a block of memory is divided into a general block and a hot block (S902).

Next, when receiving an update request for a specific logical page, it is determined whether the total number of updates of the window list is greater than or equal to a preset maximum value (S904). Here, the window is a structure containing information about the logical page to be updated and the window list is generated per file, and is a set of linked windows according to the update order.

Next, if the total number of updates is greater than or equal to the preset maximum, the window list is initialized (S906), and it is determined whether a window corresponding to the specific logical page exists in the currently existing window list (S908). If the number of updates is less than the preset maximum, step S908 is performed without going through step S906.

Hereinafter, a case in which the window for the logical page to be updated in the window list does not exist in step S908 will be described.

If there is no window for the logical page, it is determined whether the window size (number of windows) of the window list is the maximum allowable value (S910).

If the window size is the maximum allowable value, the smallest number of updates is deleted and the old window is deleted (S912). Then, a window for the logical page to be updated is allocated, and the logical page number is recorded in the window (S914). Thereafter, the update count of the window is set to 1, and the window is linked to the window list (S916).

Next, the physical page of the general block is allocated for the logical page updated according to the update request (S918).

If the window size is not the maximum allowable value in step S910, steps S914, S916, and S918 are sequentially performed for the updated logical page without performing step S912.

Hereinafter, the case in which the window for the logical page to be updated is present in the window list in step S908 will be described.

If there is a window for the logical page, it is determined whether the update count of the corresponding window is equal to or greater than the average update count of the window list (S920).

If the update count of the window is equal to or greater than the average update count, the update count of the window is increased and the window is moved to the latest position in the link structure of the window list (S922).

Subsequently, the physical page of the hot block is allocated for the logical page updated according to the update request (S924).

If the update count of the window is less than the average update count, the update count of the window is increased and the window is moved to the latest position in the link structure of the window list (S926).

Subsequently, a physical page of a general block is allocated for a logical page updated according to the update request (S928).

The above page allocation method of the memory may be implemented in the form of a program that can be executed using various computer means. In this case, the program for performing the page allocation method of the memory may be a hard disk, a CD-ROM, a DVD, a ROM ( ROM), a RAM, or a flash memory, such as a computer readable recording medium.

Those skilled in the art to which the present invention pertains will understand that the present invention can be implemented in other specific forms without changing the technical spirit or essential features.

Therefore, it is to be understood that the embodiments described above are exemplary in all respects and not restrictive. The scope of the present invention is shown by the following claims rather than the detailed description, and all changes or modifications derived from the meaning and scope of the claims and their equivalent concepts should be construed as being included in the scope of the present invention. do.

Fig. 1 shows the structure of a typical NAND flash memory of Fig. 1;

2 is a diagram illustrating a state of a memory according to a general page allocation method after file modification.

3 is a diagram illustrating a state of a memory after general block cleaning.

4 is a diagram illustrating a state of a memory after a file is modified by the page allocation method according to an exemplary embodiment of the present invention.

5 is a diagram illustrating a state of a block cleaning finished after a file is modified by the page allocation method according to an exemplary embodiment of the present invention.

FIG. 6A illustrates a window structure used to store update information of a logical page according to an embodiment of the present invention. FIG.

6B illustrates a window list in accordance with one embodiment of the present invention.

7 is a diagram illustrating movement of a window when a window of a logical page to be updated already exists in the window list according to an embodiment of the present invention.

8 is a diagram illustrating a method of adding a new window by an update request when the number of windows that can exist in the window list is the maximum according to one embodiment of the present invention;

9 is a flowchart illustrating a method of allocating a page of a memory in accordance with an embodiment of the present invention.

<Description of the symbols for the main parts of the drawings>

402: Block for hot page 404: Valid page A1

406: Valid Page B1 308: Valid Page C1

410: Valid Page D1

412: Block of area where invalid pages exist

Claims (5)

In the page allocation method of a memory including a plurality of blocks (blocks) composed of physical pages, Dividing the plurality of blocks into a first block and a second block; Calculating an update number of the specific logical page when receiving a request for updating a specific logical page; And Determining whether to allocate a physical page of the first block or the second block based on the calculated number of updates, for a specific logical page updated according to the update request; In the step of determining whether to allocate the physical page, The file including the specific logical page is composed of a plurality of logical pages, If the update count is equal to or greater than the average update count of the plurality of logical pages calculated by dividing the total update count by the number of windows, determining that the physical page of the second block is allocated to the specific logical page. How to allocate pages delete The method of claim 1, Generating window information including at least one of an update count, a logical page number, and link information for the file, for each logical page constituting the file, And allocating a physical page of the first block or the second block with respect to the specific logical page is performed based on the window information. The method of claim 3, When the update request is received, when the number of previously generated window information is the same as the maximum value of the preset createable window information and there is no window information corresponding to the specific logical page, the number of updates among the previously generated window information The method of claim 1, further comprising deleting the minimum or first generated window information and generating window information corresponding to the specific logical page. A computer-readable recording medium having recorded thereon a program for performing the memory page allocation method according to any one of claims 1, 3, and 4.

Images