KR102408150B1 - Disk Allocation Method for Manipulating Cluster Fragmentation - Google Patents

Abstract

The present invention relates to a disk allocation method capable of storing arbitrary other files stored together in a fragmented disk cluster through sequential deletion of file data by allocating data to a specified cluster through disk defragmentation.
According to the present invention, it is easy to implement by using simple file commands such as creation, deletion, and copying of files, and arbitrarily allocating and de-allocating file data to a specified cluster so that directory-related clusters and contents of files are regular. , so that files and directories on disk can be handled efficiently and easily.

Description

Disk Allocation Method for Manipulating Cluster Fragmentation

The present invention relates to a disk allocation method capable of arbitrarily manipulating the allocation of a cluster, and more particularly, to arbitrarily allocate and deallocate data to a specific cluster using simple file commands such as file creation, deletion, and copying. It relates to possible disk allocation methods.

According to the NTFS file system, file and directory information is stored in the $MFT entry in the file system, and the basic properties of the file are included in the $MFT entry and the file name of a variable size is stored. That is, the contents of the file are stored in $DATA, and if the total is less than 600KB, they are stored in the $MFT entry of 1KB size, and the maximum size of the file contents that can be stored is determined according to the length of the file name.

In the same way, in the case of directories, $INDEX_ROOT is saved as a resident attribute. About 5 to 6 file lists are stored in it, and in the case of a list more than this, $INDEX_ALLOCATION is stored as non-resident ( It is assigned to a cluster as a non-resident) attribute, and in the case of a non-resident attribute, a size of up to 4KB is stored in one cluster. At this time, if the number of lists increases, the list is saved across multiple clusters. Such information is included in the run list of $INDEX_ALLOCATION, and empty disks are usually allocated to a contiguous cluster.

9 is a Diskview screen showing the state of creating a number of files in one directory. Referring to this, when files are created in only one directory, the first directory index information is assigned to the “1st Cls.” position. do. If the number of files increases, it expands to “2nd Cls.” that can be contained after “1st Cls.” and saves it. If the number of files continuously increases, it is continuously expanded to “3rd Cls.”, “4th Cls.”, etc.

When 836 files are continuously created, the number of directory index clusters becomes much larger when the list is allocated using the file list, and clusters that store index records are continuously stored in several clusters. “Last Cls.” is a case in point.

In this way, when many files are created in one directory, the list of files is stored in several index record clusters and there is a problem that irregular and several consecutive clusters are used.

In order to solve this problem, when setting to have one index record cluster per directory, it is difficult to provide a solution because there are cases where it is difficult to use the file number for file manipulation in the directory.

Republic of Korea Patent Publication No. 10-2010-0100494 (Method and device for accessing a file or directory in a file system) Republic of Korea Patent Publication No. 10-2003-0073981 (Directory management method of large file system)

The present invention was devised to solve the problem that, when many files are created in a directory, the index record storing the file list is expanded and complexly allocated to multiple clusters irregularly. It aims to provide a disk allocation method that can allocate and deallocate data arbitrarily to a specific cluster using

In order to solve the above technical problem, the present invention comprises the steps of formatting a disk to NTFS to create a plurality of clusters, creating a plurality of target files on the disk, and allocating file data to the cluster as a file data cluster. Deleting some of the target files to deallocate some of the file data clusters, copying a target file stored on another disk to the disk, fragmenting the target file data into the file data cluster, and allocating the target file data into the file data cluster; , after deleting the remaining target files, performing disk defragmentation to continuously allocate target file data to the file data cluster.

In the present invention, the method may further include creating a root directory and sub-directories on the formatted disk, and allocating the created directory list information to the cluster as a directory list cluster.

In the present invention, the directory listing cluster may be assigned to one cluster among a plurality of generated clusters.

In the present invention, the target file may be created in the lowest sub-directory.

In the present invention, the size of each of the plurality of target files is formed to be smaller than the file data cluster, so that each of the plurality of target files can be allocated to one file data cluster.

According to the present invention, it is easy to implement by using simple file commands such as file creation, deletion, and copying, and arbitrarily allocating and de-allocating file data to a specified cluster, so that the directory-related cluster and contents of the file are regular. , so that files and directories on disk can be handled efficiently and easily.

1 is a flowchart of a disk allocation method according to an embodiment of the present invention.
2 is a disk view screen showing the cluster state of the disk after formatting.
3 is a diskview screen showing the cluster state of a disk on which a directory and a target file are created after formatting.
4 is a diskview screen showing a cluster state of a disk from which some target files have been deleted.
5 is a disk view screen showing the cluster state of the disk to which the target file is copied.
6 is a diskview screen showing the cluster state of the disk from which the remaining target files have been deleted.
7 is a disk view screen showing the storage state of the target files continuously stored in the disk cluster after the disk defragmentation is executed.
8 is a diskview screen showing the cluster state of a disk from which data at an arbitrary location has been deleted.
9 is a diskview screen showing a state in which a plurality of files are created in one directory.

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

This embodiment is provided to more completely explain the present invention to those with average knowledge in the art, and the shape of elements in the drawings, the size of elements, the spacing between elements, etc. may be exaggerated or reduced for

In addition, in the description of the embodiment, if a component is described as “included”, “coupled”, “fixed”, etc. to another component, it is directly provided, coupled, and fixed to the other component. There may be, but it should be understood that other components may exist in the middle.

In addition, when it is determined that the technical features of the present invention may be unnecessarily obscured as it is already obvious to a person skilled in the art, such as a known function or a known configuration related in principle in explaining the embodiment, the detailed description thereof A description will be omitted.

1 is a flowchart of a disk allocation method according to an embodiment of the present invention. 1 , the disk allocation method according to the present invention includes the steps of formatting the disk (S110), creating a target file and allocating file data to the cluster as a file data cluster (S120), and some of the target files De-allocating some of the file data clusters by deleting (S130), copying a target file stored in another disk to the disk, fragmenting the target file data into the file data cluster and allocating (S140); After the remaining target files are deleted, disk defragmentation is performed to continuously allocate target file data to the file data cluster (S150).

In step S110, the disk is formatted with the NTFS file system to create a plurality of clusters. In this case, a plurality of clusters formatted in NTFS may be created with a size of 4 KB.

In step S120, a directory in which the target file is located is created before the target file is created. A directory is created as a root directory and subdirectories on the formatted disk, and a plurality of target files are created in the lowest subdirectory. The directory listing information created in this way is allocated to the cluster as a directory listing cluster.

At this time, it is preferable that the created directory list cluster be allocated only to one cluster, and for this purpose, a directory name, etc. is set, and the data size of a plurality of target files is also set so that one file can be allocated to one cluster, For this purpose, each target file in the NTFS file system is formed in 800Byte ~ 4KB in size. As described above, since directory listing information and individual target files are allocated to one cluster without occupying a plurality of clusters, deletion and confirmation for each data is easy.

In step S130, a plurality of target files are successively assigned to a cluster of formatted disks. Here, if a part of the target file is deleted, the assigned file data cluster is deallocated, and some of the continuously assigned clusters are emptied. will lose

In step S140, if a target file stored on a disk different from the formatted disk is copied to the disk on which the target file is stored, it is allocated to the disk as a file data cluster. As a result, the target file data is fragmented and allocated to the cluster.

In step S150, the target file data is fragmented in the cluster and the remaining target files are deleted from the stored disk. Then, the corresponding file data cluster allocated to the remaining cluster is deallocated and emptied. Then, if the disk is defragmented, the target file data fragmented in the cluster is continuously allocated to the cluster.

Therefore, it is easy to implement by using simple file commands such as file creation, deletion, and copying, and arbitrarily allocating and de-allocating file data to a specified cluster, so that directory-related clusters and file contents can be stored regularly. Therefore, files and directories on the disk can be handled efficiently and easily.

An embodiment according to the present invention made in this way will be described below.

< Example >

1. Prepare the disc

If the disk is prepared and the target disk driver is formatted with the NTFS file system, a cluster is created in units of 4KB.

2. Calculate the total number of clusters on the disk

Then, the total number of clusters created on the disk is obtained. The number of clusters is obtained by designating an argument to the DeviceIoControl() function as FSCTL_GET_NTFS_FILE_RECORD. Or use “fsutil fsinfo ntfsinfo drive letter:” to get the total number of clusters.

3. directory depth calculation

Next, calculate the directory depth (d) as follows.

d=[log _Nidx N _cls ]

At this time, as the file is created only in the leaf directory and the directory listing information is set to occupy one cluster, the total number of clusters to be allocated (N _idx ) is the number of allocated directories (N _dir ) and the number of directories created in the leaf directory as shown below. It should be the sum of the number of files (N _files ).

N _files +N _dir < N _idx

4. directory produce

Next, create the root directory as shown below, and repeatedly create subdirectories in it, where the lowest directory level is d _dir = d-1.

makeDir(dirPrefix, d _dir , N _dir )

5. target file creation

And, d _dir as below Create multiple target files in the level. At this time, the size of each target file is created in the range of 800 bytes to 4 KB bytes, so that one target file is allocated to one cluster.

createFile(filePrefix, ext, d, N _files )

At this time, target files created in the directory can be regarded as leaf nodes in the tree, and the total number of these leaf nodes (files) for each directory is as follows.

N _files < N _idx - N _dir

6. target Delete some of the files

Next, a file to be deleted is selected with respect to the leaf node target files in the lowest directory. For example, by making the file name in the form of “filePrefix+num.ext”, files with odd numbers can be deleted for maximum fragmentation. In the delete command below, the selection of file number num is selectively performed according to the location of the cluster that you want to empty.

delete(filePrefix, ext, num)

7. Copy of defragmentation target file

Next, copy the target files (defragFiles) to be defragmented to the disk.

copyFiles(defragFiles)

8. Rest target delete file

Execute the delete command for the remaining target files left in the cluster as follows.

delete(filePrefix, ext, num)

9. Perform Disk Defragmenter

Next, defragment the disk for the remaining target files as follows,

defrag(defragFiles)

The result of disk defragmentation for the target disk is reported as follows.

reportDefrag(disk)

< Experimental example >

Experiment environment

c:fsinfo ntfsinfo g:

- NTFS Version: 3.1

- Total Sectors: 16,383 (8.0 MB)

- Total Clusters: 2,047 (8.0 MB)

- Free Clusters: 1,077 (4.2 MB)

- Total Reserved Clusters: 0 (0.0 KB)

- Reserved For Storage Reserve: 0 (0.0 KB)

- Bytes Per Sector: 512

- Bytes Per Physical Sector: 4096

- Bytes Per Cluster: 4096

- Bytes Per FileRecord Segment: 1024

- Clusters Per FileRecord Segment: 0

- Mft Valid Data Length: 256.00 KB

- Mft Start Lcn: 0x000000000000002a

- Mft2 Start Lcn: 0x00000000000000002

- Mft Zone Start: 0x000000000000002a0

- Mft Zone End: 0x00000000000003c0

- MFT Zone Size: 1.13 MB

In this environment, the experiment was assigned to one cluster per file. And, since the number of file names or directory names in the directory is affected, clusters are allocated by this, so that multiple clusters are not occupied by the list of indexes composed of B-tree. As shown below, the number of files is allocated in one directory for each index.

- File name structure (length): dataHide○○.txt (14 characters)

- Number of root directories: N _root =1

- Maximum number of files in one directory: N _idx = 35

- Total number of files created within the leaf directory: N _leaf

- The number assigned to the entire cluster is N _cls =N _leaf + N _dir

-N _cls =1,077

- d = [log _Nidx N _cls ] = [log ₃₅ 1077] = 2

-d _dir = d-1 = 1

- N _dir = N _root + N _idx ^ddir = 1 + 35 ¹ = 36

N _leaf = INT((N _cls - N _dir )/N _idx )*N _idx

+ (N _cls - N _dir ) mod N _idx

= INT((1077-36)/35) + (1077-36) mod 35

= 1,015 + 27 = 1,042

In the experiment, the files were copied to a disk formatted with the NTFS file system, fragmented to the maximum, and then the disk was defragmented.

2 shows the disk state immediately after the disk format displayed by the disk view (DiskView.exe) tool. As shown in FIG. 2 , since the partitions have a small capacity, the area marked in white is the “Empty Cluster” area. And, the green part is the “System File” part, and “$mftmirr”, “$upcase:$info”, and “$attrdef” are continuously formed in front of it. In addition, the "$mft" part marked in blue is the part where the MFT entry is stored. Immediately after formatting, it has the same shape as in FIG. 2, but if the file or directory increases, this area increases.

3 shows the disk cluster occupancy state after the target files and directories are maximally created on the disk. In FIG. 3, “Files&Dirs” indicates the occupancy status of the created directory and target file, and “$MFT” indicates the increased $MFT area accordingly.

And, FIG. 4 shows a state after deleting odd-numbered target files from among the target files created in the leaf directory. As shown in FIG. 4 , since one cluster was occupied by each file, it can be seen that even target files that were not deleted and empty cluster spaces that were deleted are alternately displayed in the image after deletion.

Fig. 4 shows the fragmentation state after copying the file.docx file of 1.15MB, which is the target file, to the disk, and Fig. 5 shows the fragmentation state in which only the target file remains after deleting even-numbered files and related directories. Next, FIG. 7 shows a state after disk defragmentation is performed on the fragmented target file (file.docx), and it can be seen that data is continuously stored in 296 clusters.

The method of deallocating any desired cluster in this way can be performed by deleting individual files created in the directory. At this time, you can use a tool such as DiskView (DiskView.exe) to obtain the information allocated for each file. In this tool, if you double-click the location of the cluster, you can obtain basic information about the location of the cluster in the case of the allocated cluster. have.

In addition, selection of a specific location is possible through the number of the generated file. Since it is implemented to occupy one cluster per file, selection of a specific location is possible through the number of files. 8 shows a process of de-allocation of an arbitrarily selected portion. Clusters contiguous to a specific location can be selected, and a regular or repeated location can be selected.

As described above, according to the present invention, it is easy to implement by using simple file commands such as file creation, deletion, and copying, and arbitrarily allocates and de-allocates file data to a specified cluster, and accordingly, directory-related clusters and contents of files This regular storage allows efficient and easy handling of files and directories on disk.

The present invention described above is not limited to the described embodiments, and it is apparent to those skilled in the art that various modifications and variations can be made without departing from the spirit and scope of the present invention. Therefore, it should be said that such variations or modifications belong to the claims of the present invention.

The present invention is the result of a project (NRF-2019R1F1A1058902) supported by the National Research Foundation of Korea (NRF).

Claims (5)

In the disk allocation method performed by the disk management device in the operating system (OS),
Formatting the disk to NTFS to create a plurality of clusters;
allocating file data to the cluster as a file data cluster by creating a plurality of target files on the disk;
de-allocating some of the file data clusters by deleting some of the target files;
copying a target file stored in another disk to the disk, fragmenting the target file data into the file data cluster and allocating; and
and allocating the target file data to the file data cluster continuously by performing disk defragmentation after deleting the remaining target files. According to claim 1,
The method further comprising: creating a root directory and sub-directories on the formatted disk, and allocating the created directory list information to the cluster as a directory list cluster. 3. The method of claim 2,
The disk allocation method, characterized in that the directory list cluster is allocated to one cluster among a plurality of created clusters. 3. The method of claim 2,
The disk allocation method, characterized in that the target file is created in the lowest sub-directory. 5. The method of claim 4,
Each of the plurality of target files is formed to have a size smaller than the file data cluster, so that each of the plurality of target files is allocated to one file data cluster.

Images