# Patent

## Title
Fast algorithm to find file system difference for deduplication

## Abstract

The disclosure provides techniques for deduplicating files. The techniques include, upon creating or modifying a file, placing a logical timestamp of the current logical time, within a queue associated with the directory of the file. The techniques further include placing the logical timestamp within a queue of each parent directory of the directory of the file. To determine a set of files for deduplication, the techniques disclosed herein identify files that have been modified within a logical time range. The set of files modified within a logical time is identified by traversing directories of a storage system, the directories being organized within a tree structure. If a directory's queue does not contain a timestamp that is within the logical time range, then all child directories can be skipped over for further processing, such that no files within the child directories end up being within the set of files for deduplication.

## Background
RELATED APPLICATIONS
This application is related to U.S. application Ser. No. 16/552,880, titled “SCALE OUT CHUNK STORE TO MULTIPLE NODES TO ALLOW CONCURRENT DEDUPLICATION,” U.S. application Ser. No. 16/552,908, titled “A PROBABILISTIC ALGORITHM TO CHECK WHETHER A FILE IS UNIQUE FOR DEDUPLICATION,” U.S. application Ser. No. 16/552,954, titled “EFFICIENT GARBAGE COLLECTION OF VARIABLE SIZE CHUNKING DEDUPLICATION,” U.S. application Ser. No. 16/552,998, titled “ORGANIZE CHUNK STORE TO PRESERVE LOCALITY OF HASH VALUES AND REFERENCE COUNTS FOR DEDUPLICATION,” and U.S. application Ser. No. 16/552,976, titled “SMALL IN-MEMORY CACHE TO SPEED UP CHUNK STORE OPERATION FOR DEDUPLICATION.” Each of these applications is filed on the same day as the present application. The entire contents of each of these applications are hereby incorporated by reference herein.
BACKGROUND
The amount of data worldwide grows each year at a rate that is faster than the price drop of storage devices. Thus, the total cost of storing data continues to increase. As a result, it is increasingly important to develop and improve data efficiency techniques, such as deduplication and compression for file and storage systems. Data deduplication works by calculating a hash value for each data unit and then storing units with the same hash only once. One issue that arises in data deduplication systems is efficiently identifying files that need to be deduplicated at a given point in time. Scanning all files in the system may be cost and time prohibitive.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1A depicts a block diagram of a computer system in which one or more embodiments of the present disclosure may be utilized.
FIG. 1B depicts a block diagram of a cache within a memory of a host machine, according to an embodiment.
FIG. 1C depicts a block diagram of an exemplary chunk hash table and an exemplary chunk ID table, according to an embodiment.
FIG. 2 depicts a block diagram of two exemplary files, according to an embodiment.
FIG. 3 depicts a flow diagram of a method of deduplicating a file, according to an embodiment.
FIG. 4 depicts a flow diagram of a method of updating a file that has been previously deduped, according to an embodiment.
FIG. 5 depicts a block diagram of an exemplary file system tree, according to an embodiment.
FIG. 6 depicts a flow diagram of a method of updating a timestamp queue of a directory when a file is created or modified, according to an embodiment.
FIG. 7 depicts a flow diagram of a method of identifying files for deduplication, and deduplicating the identified files, according to an embodiment.
FIG. 8 depicts a flow diagram of a method of identifying files that were modified or recreated during the logical range determined by the method of FIG. 7, according to an embodiment.



To facilitate understanding, identical reference numerals have been used, where possible, to designate identical elements that are common to the figures. It is contemplated that elements disclosed in one embodiment may be beneficially utilized on other embodiments without specific recitation.
DETAILED DESCRIPTION
The present disclosure provides techniques for identifying files for deduplication. The techniques include marking directories of files with logical timestamps so as to skip entire subtrees of the directory structure while searching for files to deduplicate. Skipping searching of subtrees of a directory structure allows identification of files for deduplication to be faster than if every directory is searched. Skipping also uses less of other computing resources, such as processing and memory. This improves the functioning of the computer itself, and also improves the functioning of a computer's storage system. The techniques herein are directed to a specific implementation of a solution to a problem in the software arts.
More specifically, techniques include, upon creating or modifying a file, placing a logical timestamp of a current logical time, within a queue associated with the directory of the file. The techniques further include placing the logical timestamp within a queue of each parent directory of the directory of the file. To determine a set of files for deduplication, the techniques disclosed herein identify files that have been modified within a logical time range. The set of files modified within a logical time range is identified by traversing directories of a storage system, the directories being organized within a tree structure. If a directory's queue does not contain a timestamp that is within the logical time range, then all child directories can be skipped over for further processing, such that no files within the child directories end up being within the set of files for deduplication.
The present disclosure also provides techniques for deduplicating files. The techniques include creating a data structure that organizes metadata about chunks of files, the organization of the metadata preserving order and locality of the chunks within files. A chunk of a file is a portion of a file, as described further below. Order and locality are further described below with reference to FIG. 1C and FIG. 2. The organization of the metadata within storage blocks of storage devices matches the order of chunks within files. Upon a read or write operation to a metadata, the preservation of locality of metadata results in the likely pre-fetching, from storage into a memory cache, metadata of subsequent and contiguous chunks. The preserved locality results in faster subsequent read and write operations of metadata, because the read and write operations are executed from memory rather than from storage.
The faster read and write operations result in an improvement in the functioning of the computer itself. The computer is able to execute basic read and write operations faster than otherwise. Additionally, an improvement in a deduplication process results in an improvement in the functioning of the computer itself. An improvement in deduplication improves the way a computer stores and retrieves data in memory and in storage. The deduplication techniques herein are directed to a specific implementation of a solution to a problem in the software arts.
FIG. 1A depicts a block diagram of a computer system 100 in which one or more embodiments of the present disclosure may be utilized. Computer system 100 includes a data center 102 connected to a network 146. Network 146 may be, for example, a direct link, a local area network (LAN), a wide area network (WAN) such as the Internet, another type of network, or a combination of these.
Data center 102 includes host(s) 105, a virtualization manager 130, a gateway 124, a management network 126, a data network 122, and a chunk store 134. Networks 122, 126, in one embodiment, each provide Layer 2 or Layer 3 connectivity in accordance with the Open Systems Interconnection (OSI) model, with internal physical or software defined switches and routers not being shown. Although the management and data network are shown as separate physical networks, it is also possible in some implementations to logically isolate the management network from the data network, e.g., by using different VLAN identifiers.
Each of hosts 105 may be constructed on a server grade hardware platform 106, such as an x86 architecture platform. For example, hosts 105 may be geographically co-located servers on the same rack.
Hardware platform 106 of each host 105 may include components of a computing device such as one or more central processing units (CPUs) 108, system memory 110, a network interface 112, storage system 114, a host bus adapter (HBA) 115, and other I/O devices such as, for example, USB interfaces (not shown). Network interface 112 enables host 105 to communicate with other devices via a communication medium, such as data network 122 or management network 126. Network interface 112 may include one or more network adapters, also referred to as Network Interface Cards (NICs). In certain embodiments, data network 122 and management network 126 may be different physical networks as shown, and the hosts 105 may be connected to each of the data network 122 and management network 126 via separate NICs or separate ports on the same NIC. In certain embodiments, data network 122 and management network 126 may correspond to the same physical or software defined network, but different network segments, such as different VLAN segments.
Storage system 114 represents persistent storage devices (e.g., one or more hard disks, flash memory modules, solid state disks, non-volatile memory express (NVMe) drive, and/or optical disks). Storage 114 may be internal to host 105, or may be external to host 105 and shared by a plurality of hosts 105, coupled via HBA 115 or NIC 112, such as over a network. Storage 114 may be a storage area network (SAN) connected to host 105 by way of a distinct storage network (not shown) or via data network 122, e.g., when using iSCSI or FCoE storage protocols. Storage 114 may also be a network-attached storage (NAS) or another network data storage system, which may be accessible via NIC 112.
System memory 110 is hardware allowing information, such as executable instructions, configurations, and other data, to be stored and retrieved. Memory 110 is where programs and data are kept when CPU 108 is actively using them. Memory 110 may be volatile memory or non-volatile memory. Memory 110 also includes a cache 132 (see FIG. 1B). Although cache 132 is shown as located within memory 110, cache 132 may be implemented in other components of computer system 100, such as in an external storage or memory device, shared by a plurality of hosts 105, and coupled to host 105 via HBA 115 or NIC 112. Cache 132 comprises cached copies of storage blocks of storage(s) 114. The cached storage blocks in cache 132 are fetched into memory 110 during deduplication method 300 discussed below with reference to FIG. 3.
Host 105 is configured to provide a virtualization layer, also referred to as a hypervisor 116, that abstracts processor, memory, storage, and networking resources of hardware platform 106 into multiple virtual machines 1201 to 120N (collectively referred to as VMs 120 and individually referred to as VM 120) that run concurrently on the same host. Hypervisor 116 may run on top of the operating system in host 105. In some embodiments, hypervisor 116 can be installed as system level software directly on hardware platform 106 of host 105 (often referred to as “bare metal” installation) and be conceptually interposed between the physical hardware and the guest operating systems executing in the virtual machines. In some implementations, the hypervisor may comprise system level software as well as a “Domain 0” or “Root Partition” virtual machine (not shown) which is a privileged virtual machine that has access to the physical hardware resources of the host and interfaces directly with physical I/O devices using device drivers that reside in the privileged virtual machine. Although the disclosure is described with reference to VMs, the teachings herein also apply to other types of virtual computing instances (VCIs), such as containers, Docker containers, data compute nodes, isolated user space instances, namespace containers, and the like. In certain embodiments, instead of VMs 120, the techniques may be performed using containers that run on host 105 without the use of a hypervisor and without the use of a separate guest operating system running on each container.
Virtualization manager 130 communicates with hosts 105 via a network, shown as a management network 126, and carries out administrative tasks for data center 102 such as managing hosts 105, managing VMs 120 running within each host 105, provisioning VMs, migrating VMs from one host to another host, and load balancing between hosts 105. Virtualization manager 130 may be a computer program that resides and executes in a central server in data center 102 or, alternatively, virtualization manager 130 may run as a virtual computing instance (e.g., a VM) in one of hosts 105. Although shown as a single unit, virtualization manager 130 may be implemented as a distributed or clustered system. That is, virtualization manager 130 may include multiple servers or virtual computing instances that implement management plane functions.
Although hosts 105 are shown as comprising a hypervisor 116 and virtual machines 120, in an embodiment, hosts 105 may comprise a standard operating system instead of a hypervisor 116, and hosts 105 may not comprise VMs 120. In this embodiment, data center 102 may not comprise virtualization manager 130.
Gateway 124 provides hosts 105, VMs 120 and other components in data center 102 with connectivity to one or more networks used to communicate with one or more remote data centers. Gateway 124 may manage external public Internet Protocol (IP) addresses for VMs 120 and route traffic incoming to and outgoing from data center 102 and provide networking services, such as firewalls, network address translation (NAT), dynamic host configuration protocol (DHCP), and load balancing. Gateway 124 may use data network 122 to transmit data network packets to hosts 105. Gateway 124 may be a virtual appliance, a physical device, or a software module running within host 105.
Chunk store 134 comprises storages 114, tables 140, 142, 172, deduplication module 144, and a global logical clock (GLC) 174. Chunk store 134 is a storage system that stores data of files 200 (see FIG. 2). The data of files 200 within chunk store 134 is deduplicated by deduplication module 144.
GLC 174 is a counter that is incremented at specific time points, at specific points in processes described herein, or at a specific time intervals, as appropriate for system 100. Each historical value of GLC 174 represents a temporal checkpoint. The checkpoints are used to identify files 200 (see FIG. 2) for deduplication, as further described below with reference to FIGS. 5, 6, 7, and 8. The logical time of GLC 174 may be a monotonic value that increases when it changes.
Deduplication module 144 may be a background process working asynchronously relative to input/output (I/O) operations directed to chunk store 134, such as asynchronously relative to I/O operations by hosts 105 or VMs 120. Deduplication module 144 may be software running within hypervisor 116, memory 110, VM 120, storage 114, or within another component of system 100. Deduplication module 144 may be a separate physical device connected to chunk store 134. Host 105 or system 100 may comprise one or more deduplication modules 144. Deduplication module 144 may be associated with a virtual node running on host 105, as described in U.S. application Ser. No. 16/552,880, incorporated by reference above.
One method of deduplication that may be used by deduplication module 144 is described in U.S. application Ser. No. 12/356,921, titled “Computer Storage Deduplication,” filed on Jan. 21, 2009, the entire content of which is hereby incorporated by reference herein. The method of deduplication that may be used by deduplication module 144 may be that described in application Ser. No. 12/356,921, as modified by techniques disclosed herein.
Chunk store 134 comprises one or more storage devices 114. Although the storage devices of chunk store 134 are shown as storage devices 114 of host 105, storage devices of chunk store 134 may be any storage devices such as other storages that may be connected to host 105 through HBA 115. In an embodiment, chunk store 134 may be a distributed storage system implemented as an aggregation of storage devices 114 accessible by a plurality of hosts 105. In such a distributed storage system, chunk store 134 may be a virtual storage area network (vSAN), and hypervisor 116 may comprise a vSAN module (not shown), as described in U.S. application Ser. No. 14/010,247, titled “Distributed Policy-Based Provisioning and Enforcement for Quality of Service,” filed on Aug. 26, 2013, now U.S. Pat. No. 9,887,924, the entire content of which is hereby incorporated by reference herein.
FIG. 2 depicts a block diagram of two exemplary files 200, according to an embodiment. Storage devices 114 of chunk store 134 store files 200. Each file 200 may be associated with a “modification time,” which may be the real-world time at which the file was last modified. If the file was last modified when it was created, then a file's modification time may be the same as the file's creation time. The modification time of a file 200 may be stored as metadata or as part of the data or content of file 200, within one or more chunks 202 of file 200.
Each file 200 is divided into portions or chunks 202. In an embodiment, deduplication performed herein is byte-level deduplication. With byte-level deduplication, file 200 may be divided into chunks 202 by the following exemplary process. Deduplication module 144 chooses a small window size and computes a hash for a byte window starting at every byte offset of file 200. This can be done efficiently using Rabin fingerprints. If the hash matches a fixed value (e.g., zero), deduplication module 144 considers that file offset to be a boundary. Such a boundary is called a content-based boundary. A chunk 202 may be defined to be the file data between two boundaries. A boundary may also be the start and end of file 200.
Deduplication module 144 then computes a second hash for each chunk 202, and this is the hash that is checked against and inserted into chunk store data structures 140 and 142, as further described below. The second hash may be computed by, for example, a hash algorithm such as secure hash algorithm (SHA)-256 or SHA-512. In an embodiment, the computed hash may be truncated, and the truncated hash is the second hash that is associated with a chunk 202, as further described with reference to FIG. 3, below.
A benefit of such a method of dividing a file 200 into chunks 202 is that, if data in file 200 shifted (e.g., a new line is inserted at the beginning of file 200), most chunks 202 in file 200 are not affected. Such boundary setting may result in the detection of more duplicated content and may achieve increased storage space saving via deduplication. The average size of chunk 202 may be, for example, approximately 80 KB. Chunks 202 may be of different sizes.
Returning to FIG. 1A, chunk store 134 also comprises three data structures: time table 172, chunk hash table 140, and chunk ID table 142. Although tables 140, 142, and 172 are described as “tables,” these data structures may be any data structure that can perform the functions of chunk hash table 140, chunk ID table 142, and/or time table 172. Tables 140, 142, and 172 may not be the same data structure, or may be the same data structure. For example, the data structures may be an log structured merge (LSM) tree, a Bε tree, or a B+ tree. Chunk hash table 140 may be implemented as a file directory with each entry in chunk hash table being a file, as further described in U.S. application Ser. No. 16/552,880, incorporated by reference above.
Time table 172 is a key-value data structure that, when given a key, returns a value that is mapped to that key. The key-value mappings are mappings from the key to the value. Each key-value mapping is between (a) the key, which is a GLC logical time, and (b) the value, which is a real-world time. A logical time may be for example, a numerical number such as “1,” “2,” “3,” etc. A real-world time may be a time that indicates the current time in the world, such as for example “Oct. 12, 2018, 1:42:59 PM Pacific Time Zone.”
Chunk hash table 140 is shown in detail in FIG. 1C. Chunk hash table 140 is a key-value data structure that, when given a key, returns a value that is mapped to that key. The key-value mappings are mappings from the key to the value. Chunk hash table 140 includes key-value mappings, each mapping being between (a) the key, which is the hash of the contents of chunk 202 (i.e., chunk hash 150), and (b) the value, which is a chunk identifier (ID) 152. Chunk ID 152 is an arbitrarily assigned alphanumeric identifier that preserves locality and sequential order of chunks 202 of file 200. For example, chunk 202A of file 2001 may be assigned the arbitrary chunk ID of “650.” Chunk 202B may then be assigned the next sequential, contiguous chunk ID, such as “651.” Chunk 202c may be assigned a chunk ID of “652,” etc. It should be noted that “contiguous” may be defined in arbitrary increments within system 100. For example, contiguity may be defined in increments of 0.5 or 10. If contiguity is defined in increments of 0.5, then after chunk ID “650,” the next contiguous chunk ID is “650.5.” If contiguity is defined in increments of 10, then after chunk ID “650,” the next contiguous chunk ID is “660.” Chunk IDs 152 may be sourced from a reserved batch of contiguous chunk IDs 152, as discussed in U.S. application Ser. No. 16/552,880, incorporated by reference above.
Chunk ID table 142 is shown in detail in FIG. 1C. Chunk ID table 142 is a key-value data structure that, when given a key, returns a value that is mapped to that key. The key-value mappings are mappings from the key to the value. Chunk ID table 142 includes key-value mappings, each mapping being between (a) the key, which is chunk ID 152 (e.g., obtained from chunk hash table 140), and (b) the value, which is a set of information 158 about chunk 202 corresponding to that chunk ID 152. Set of information 158 may be considered “metadata” about chunk 202 corresponding to chunk ID 152 mapped to the set of information 158. Set of information 158 may include: chunk hash 150, a pointer 154 to the contents of chunk 202 within chunk store 134, and a reference count 156 of chunk 202. Pointer 154 to the contents of chunk 202 may include an address, such as a logical or physical address. Pointer 154 may be a plurality of pointers 154 pointing to locations of file 200 within storage(s) 114. Pointer 154 may be a plurality of pointers if, for example, file 200 is a fragmented file, stored in more than one location within storage(s) 114. In an embodiment, pointer 154 is a logical pointer 154. Reference count 156 of chunk 202 may be the number of pointers (e.g., pointers 154 and pointers of files 200) that point to the contents of chunk 202. In an embodiment, reference counts 156 may be stored in a separate data structure and created, modified, and generally managed as described in U.S. application Ser. No. 16/552,954, incorporated by reference above. Tables 140 and 142 may be regarded as containing “metadata” of the content or data of chunks 202.
FIG. 3 depicts a flow diagram of a method 300 of deduplicating a file 200, according to an embodiment. Method 300 may be performed by deduplication module 144. Method 300 may be performed in the background, asynchronously relative to I/O operations directed to chunk store 134. The file 200 deduplicated by method 300 may be obtained from a list of files 200 identified for deduplication, and the list of files 200 may be identified by method 800 of FIG. 8, described below.
At step 305, deduplication module 144 creates boundaries within file 200 so as to divide file 200 into chunks 202. Step 305 may be performed by a process that includes Rabin fingerprinting, as described above with reference to FIG. 2.
At step 310, deduplication module 144 chooses a first or next chunk 202 for processing in subsequent steps of method 300. If step 310 is reached from step 305, then method 300 has just began its first iteration, and so deduplication module 144 chooses the first chunk 202 of file 200. If step 310 is reached from step 355, then method 300 is restarting a new iteration, and so deduplication module 144 chooses the next chunk 202 of file 200.
As part of step 310, deduplication module 144 computes a hash of the data of chosen chunk 202. The hash may be computed by, for example, SHA-256 or SHA-512. In an embodiment, the computed hash may be truncated (e.g., a SHA-512 hash may be truncated to 256 bits), and the truncated hash is the hash that is “computed at step 310” for subsequent steps of method 300.
At step 315, deduplication module 144 determines whether the hash of chunk 202, computed at step 310, is in chunk hash table 140. If so, then the identical contents of chunk 202 have been previously processed by deduplication module 144, such as for example as part of a previous execution of method 300. Also if so, then a chunk identical to chunk 202 is already present within chunk store 134. If identical contents of chunk 202 have been previously processed, then an entry for hash 150 and chunk ID 152 for contents of chunk 202 already exist within chunk hash table 140, the entry having been added by a previous execution of method 300. If the hash of chunk 202 is in chunk hash table 140, then method 300 continues to step 330. Optionally, if the hash of chunk 202 is in chunk hash table 140, then as part of step 315, deduplication module 144 extracts chunk ID 152 from chunk hash table 140.
If the hash of chunk 202 is not in chunk hash table 140, then the contents of chunk 202 have not been previously deduplicated through the processing of method 300, and method 300 proceeds to step 320.
At step 320, deduplication module 144 adds an entry for chunk 202 to chunk hash table 140. As discussed above, an entry in chunk hash table 140 includes a key-value mapping between (a) the key, which is the hash of the contents of chunk 202 (i.e., chunk hash 150), and (b) the value, which is a chunk ID 152. Chunk hash 150 was computed at step 310. Chunk ID 152 is assigned to chunk 202 as described above with reference to FIG. 2. If chunk 202 chosen at step 310 is the first chunk 202 of a file (e.g., chunk 202A of file 2001), then chunk ID 152 may be assigned arbitrarily. If chunk 202 chosen at step 310 is a second or subsequent chunk 202 (e.g., chunk 202B of file 2001), then chunk ID may be the next sequential identifier after chunk ID 152 assigned to the previous chunk 202. Previous chunk 202 may be, for example, chunk 202A of file 2001.
At step 325, deduplication module 144 adds an entry for chunk 202 to chunk ID table 142. As described above, an entry in chunk ID table 142 includes a key-value mapping between (a) the key, which is the chunk ID 152 assigned at step 320, and (b) the value, which is a set of information 158 about chunk 202 corresponding to that chunk ID 152. As part of step 325, reference count 156 is modified to indicate that a reference to chunk 202 exists in chunk ID table 142 and in file 200 being deduped. In an embodiment, the reference count is set to or incremented by one. As part of step 325, the storage block to which an entry for chunk 202 is added is copied or fetched from one of storages 114 into cache 132. This copying of the storage block into memory 110 may be an automatic part of caching and swapping operations performed by hypervisor 116, an operating system of host 105, and/or a guest operating system of VM 120. After step 325, method 300 continues to step 355.
At step 330, deduplication module 144 uses chunk ID 152 extracted from chunk hash table 140 at step 315 to send a request to obtain set of information 158 about chunk 202. The set of information 158 is requested from chunk ID table 142. Deduplication module 144 uses chunk ID 152 as a key into chunk ID table 142. The value returned (at step 330 or a subsequent step) is the set of information 158 about chunk 202. Deduplication module 144 first checks whether the set of information 158 is in cache 132 before checking storage 114 of chunk store 134.
At step 335, deduplication module 144 determines whether the set of information 158 is in cache 132. If so, then method 300 skips step 340 and continues to step 345. If not, then method 300 continues to step 340.
At step 340, the storage block on which the set of information 158 is stored is copied or fetched from one of storages 114 into cache 132. As part of step 340, deduplication module 144 obtains from block cache 132 the set of information 158 associated with chunk 202. This copying of the storage block into memory 110 may be an automatic part of caching and swapping operations performed by hypervisor 116, an operating system of host 105, and/or a guest operating system of VM 120.
In an embodiment, when the storage block containing the set of information corresponding to a given chunk ID is copied from storage 114 to cache 132, the contents of the chunks 202 (that correspond to chunk IDs 152 in the storage block) are not copied into cache 132.
It should be noted that the entries in chunk ID table 142 are arranged or organized by sequential and contiguous chunk IDs 152. The entries of chunk ID table 142 may be stored sequentially and contiguously in storage 114. This means that a storage block containing the set of information 158 corresponding to a given chunk ID 152 is likely to also store the sets of information 158 corresponding to a plurality of chunk IDs 152 that are before and/or after the given chunk ID 152. The sets of information 158 within the storage block may be arranged contiguously with one another (in an embodiment, unseparated by other data), in an order that matches the order of associated chunk IDs 152. For example, if a storage block stores the set of information corresponding to chunk ID 152 of chunk 202B of file 2001, then that same storage block is likely to also store the set of information corresponding to the chunk IDs 152 of chunks 202A, 202C, and 202D.
The advantage of preserving locality by organizing sets of information 158, within chunk ID table 142, by sequential and contiguous chunk IDs 152, is illustrated with respect to the following example. Assume file 2001 has already been deduped and file 2002 is in the process of being deduped by method 300. As used herein, the terms “deduped” and “deduplicated” are synonymous, and mean “having gone through a process of deduplication.” Assume that at step 315, the hash of chunk 202E of file 2002 is determined to already be within chunk hash table 140, meaning that a chunk identical to 202E is already in chunk store 134. Assume that this previously deduped and identical chunk 202 is chunk 202A of file 2001. It is likely that after chunk 202A, the subsequent several chunks 202B, 202C, 202D, etc. of file 2001 are the same as the several chunks following chunk 202E of file 2002. The sets of information 158 corresponding to chunks 202B, 202C, and 202D are likely within the same storage block as the set of information 158 of chunk 202A. When the storage block containing set of information 158 of chunk 202A is copied into cache 132 of memory 110, the sets of information 158 corresponding to chunks 202B, 202C, and 202D are also likely copied into cache 132. When, for example, 202F of file 2002 is processed by method 300, the hash of the contents of chunk 202F is likely to be the same as the hash of chunk 202B. The hash of chunk 202B is already in chunk hash table 140 and chunk ID table 142 as chunk hash 150.
When the hash of chunk 202F is calculated, set of information 158 corresponding to that hash is likely to already be in cache 132, precluding a need to copy a new storage block into cache 132 as part of an I/O operation, as illustrated by the skipping of step 340 if a cache hit occurs in step 335 of method 300. This speeds up processing and deduplication of files 200. Organizing the sets of information, within chunk ID table 142, by sequential and contiguous chunk IDs 152, preserves locality of deduped files 200. The preserved locality results in faster read operations of sets of information 158, because the read operations are executed from memory 110 rather than from storage 114.
At step 345, deduplication module 144 checks that the hash calculated at step 310 is the same as chunk hash 150 within the obtained set of information 158. If not, then method 300 may abort and an administrator may be notified. If the hashes match, then deduplication module 144 performs a write to the storage block copied into cache at step 340. The write increases reference count 156, within the set of information 158, by one. The increase by one indicates that the portion of file 200 corresponding to chunk 202 chosen at step 310 is now pointing to the chunk 202 that had already been in chunk store 134 (and whose set of information 158 was obtained at previous steps).
At step 350, a deduplication module 144 or a garbage collection module (not shown) unreserves storage space within storage 114. The unreserved storage space corresponds to the space where chunk 202 chosen at step 310 is stored. The freeing or unreserving of storage blocks may be performed as described by U.S. application Ser. No. 16/552,954, incorporated by reference above. As part of step 350, the portion of file 200 that previously pointed to chunk 202 chosen at step 310 is remapped to point at shared chunk 202 that had already been in chunk store 134, and whose set of information 158 was retrieved at steps 330-340. As used herein, a “shared chunk” 202 is a chunk that is referenced by more than one file 200.
As part of step 350, memory pages corresponding to shared chunk 202, whose set of information 158 was retrieved at steps 330-340, are marked as copy-on-write (COW). Marking pages as COW may be performed by hypervisor 116 or an operating system of host 105 or VM 120. Step 350 may be performed before, concurrently, or after step 345.
At step 355, deduplication module 144 determines whether more chunks 202 of file 200 (of step 305) need to be processed by method 300. If so, method 300 returns to step 310. Otherwise, method 300 ends.
FIG. 4 depicts a flow diagram of a method 400 of updating a file 200 that has been previously deduped, according to an embodiment. Method 400 may be performed by deduplication module 144, hypervisor 116, an operating system of host 105 or VM 120, or a combination of these components. The file 200 that has been previously deduped may have been deduped by method 300.
At step 402, deduplication module 144 (or hypervisor 116 or an operating system of host 105 or VM 120) marks memory pages of a shared chunk 202 as COW. Step 402 may be performed as part of method 300, such as part of step 350 of method 300.
At step 404, chunk store 134 or hypervisor 116 receives an operation to update a file 200 that references the shared chunk 202, and the update operation is directed at contents of shared chunk 202.
At step 406, chunk store 134 or hypervisor 116 creates a copy of shared chunk 202, the copy being a new chunk 202 with updated data, as per the update operation of step 404.
At step 408, an entry for new chunk 202 is added to chunk hash table 140, similarly to the process of step 320 of method 300. Also as part of step 408, an entry for new chunk 202 is added to chunk ID table 142, similarly to the process of step 325 of method 300.
At step 410, the portion of updated file 200 that previously pointed to shared chunk 202 is remapped to point to new chunk 202. Because file 200 is remapped to a new chunk, shared chunk 200 may no longer be a “shared chunk” at step 410. As part of step 410 or as part of another step of method 400, the memory pages of previously shared chunk 202 may be unmarked COW.
At step 412, deduplication module 144 decreases the reference count of the shared chunk or previously shared chunk 202 by one. After step 412, method 400 ends.
FIG. 5 depicts a block diagram of an exemplary file system tree 500, according to an embodiment. Tree 500 represents organization or hierarchy of files 200 within chunk store 134 and/or storage(s) 114A. Directory 502 may be, for example, an electronic folder as commonly known in the art. Each directory 502 may have any number of child files 200 or child directories 502. A “child” file 200 or directory 502 may be regarded as contained within its parent directory 502. A child file 200 or child directory 502 may be a direct or indirect child.
As used herein, a “direct child” of a parent directory 502 is a file 200 or directory 502 located directly underneath the parent directory 502 in the tree 500. In FIG. 5, a direct child is connected to a parent without an intermediary directory 502 between the child and the parent. For example, file 2001 is a direct child of directory 502B, and directory 502B is a direct parent of file 2001. For another example, directory 502F is a direct child of directory 502E, and directory 502E is a direct parent of directory 502F.
An “indirect child” is a file 200 or directory 502 located indirectly underneath an indirect parent directory 502. In FIG. 5, an indirect child is connected to an indirect parent with an intermediary directory 502 being present between the child and parent. An indirect parent may be referred to as an “ancestor,” and an indirect child may be referred to as a “descendant.” For example, directory 502E is an ancestor of directory 502D and directory 502F. Directory 502E is a “common” ancestor of directory 502D and directory 502F, because directory 502E is an ancestor of both directory 502D and directory 502F.
Each directory 502 is associated with or comprises a timestamp queue (TQ) 504. In an embodiment, TQ 504 is stored as a property or an attribute of its associated directory 502. TQ 504 may be, for example, an array data structure. TQ 504 may be limited in the number of entries that it may contain, such as for example, five entries, ten entries, or a hundred entries. Each entry within TQ 504 is a logical timestamp. The logical timestamp is the GLC logical time of GLC 174 at the time that the timestamp is added to TQ 504. Adding a timestamp to TQ 504 of directory 502 may be referred to as “marking” that directory 502 with the timestamp. If TQ 504 of directory 502 contains a timestamp, then that directory 502 may be regarded as “marked” by that timestamp. Adding timestamps to TQ 504 is further described below with reference to FIG. 6.
FIG. 6 depicts a flow diagram of a method 600 of updating a TQ 504 of a directory 502 when a file 200 is created or modified, according to an embodiment. Method 600 may be performed by the file system of chunk store 134 and/or storage(s) 114.
The following is a summary of method 600. When a file 200 is updated or newly created, method 600 checks whether the directory 502 in which the file 200 is located has been labeled with a timestamp of current logical time of GLC 174. If not, then that directory is labeled with the current logical time. The same determination and timestamping is performed for each parent and ancestor directory 502 of the file 200, up tree 500, until either (a) a directory 502 is reached that has been labeled with the current logical time (e.g., such as from a previous execution of method 600 for a different file 200), or (b), the root directory 502 is reached and there are no more parent or ancestor directories 502 to evaluate.
Although it might appear expensive in terms of time and computing resources to perform method 600 upon each modification or creation of a file 200, the stopping of method 600 when a parent or ancestor directory 502 with an updated timestamp is reached causes method 600 to have a reduced number of steps before method 600 ends.
At step 602, a file 200 within storage 114 is created or modified. The file 200 may be, for example, file 2002.
At step 604, the modification time of the file 200 of step 602 is updated. The modification time of file 200 may be the real-world time at the time of modifying or creating the file 200.
At step 606, the component of system 100 performing method 600 (e.g., file system of chunk store 134 and/or storage(s) 114) chooses the next parent directory 502 up tree 500 for evaluation of and modification of timestamps.
If step 606 is reached from step 604, then the component performing method 600 chooses directory 502 of the updated or modified file 200 for further analysis by method 600. Directory 502 of file 200 may be the directory 502 containing file 200, or directory 502 that is the direct parent of file 200. Continuing the above example, directory 502D may be chosen, because directory 502D is the parent directory of file 2002.
If step 606 is reached from step 612, then the direct parent directory 502 of the current chosen directory 502 is chosen.
At step 608, TQ 504 of the chosen directory 502 is accessed to determine TQ 504 contains a timestamp that is equal to the current logical time of GLC 174. If TQ 504 contains a timestamp equal to the current logical time of GLC 174, then the current directory 502 and all parent and ancestor directories 502 have already had their associated TQs 504 updated to include the current logical time of GLC 174, and so method 600 ends. If TQ 504 does not contain a timestamp equal to the current logical time of GLC 174, then method 600 continues to step 610.
At step 610, the current logical time of GLC 174 is obtained from GLC 174 and then added to or inserted into TQ 504 of directory 502 chosen at step 606. If TQ 504 is full at the start of step 610, then the earliest (i.e., oldest) or smallest timestamp within TQ 504 may be evicted from TQ 504.
At step 612, the component performing method 600 determines whether the current directory 502 has a parent directory 502, or whether the current directory 502 is the root directory 502. In FIG. 5, the root directory 502 is directory 502A. The current directory 502 is the directory chosen at step 606. If no parent directory 502 exists, then all parent and ancestor directories of the modified file 200 have had their associated TQs 504 updated to include the current logical time of GLC 174, and so method 600 ends. If a parent directory 502 exists, then method 600 returns to step 606, at which the next up parent directory 502 is chosen for timestamp evaluation. Following the above example, the current directory 502 is directory 502, and method 600 returns to step 606 at which step directory 502C is chosen for timestamp evaluation.
It should be noted that in many cycles through iterations of steps 606 through 612 may be required if many directories 502 exist between the directory 502 where the file 200 being modified is located. This could create a deadlock of one or more processors 108. The deadlock problem may be solved using the following embodiment of method 600.
Tree 500 is traversed from (a) child directory 502 that contains modified/created file 200 to (b) parent directory 502 using back-link pointers from the child directory 502 to its parent directory 502. To avoid deadlock, try-lock/release-all is used to obtain the lock of the inode (not shown) of the parent directory 502. Once the last directory 502 that needs to be updated is reached, then the component performing method 600 moves down tree 500 toward the child directory 502 that contains modified/created file 200 to perform the actual updates (i.e., step 610 of method 600). Because the ancestor of child directory 502 has been locked, no other transaction can change the sub-tree rooted at that ancestor. To avoid generating a large update transaction from the ancestor directory 502 to a child directory 502, the transaction may be broken up into smaller chained transactions, implemented using standard techniques.
FIG. 7 depicts a flow diagram of a method 700 of identifying files 200 for deduplication, and deduplicating the identified files 200, according to an embodiment. Method 700 may be performed by deduplication module 144.
At step 702, deduplication module 144 obtains the current logical time of GLC 174.
At step 704, deduplication module or another component of system 100 increments GLC 174. Although incrementing GLC 174 is described as occurring at this point within method 700, incrementing of GLC 174 may occur at other times within, before, after, or between the methods described herein, as appropriate. For example, GLC 174 may be incremented before step 710 between steps 710 and 712, after step 712, or at some point within method 300.
At step 706, deduplication module 144, the file system of chunk store 134 and/or storage(s) 114, or another component of system 100 adds an entry within time table 172. The entry maps (a) the new logical time of GLC 174, attained after incrementing of GLC 174, to (b) real-world time at the time of incrementing GLC 174.
At step 708, deduplication module 144 determines a logical range for identification of files 200 for deduplication. For example, if at a previous execution of method 700, all files that were created or modified within the logical time range of 1-3 were deduplicated, then deduplication module 144 may determine that a logical range of 4-5 is the appropriate logical range. In an embodiment, the logical range may be determined so as to exclude files 200 that were modified or created “recently.” For the purpose of step 708, “recently” may mean, for example, a most recent length of threshold of time, such as the previous 24 hours. The reason for excluding files 200 that were recently created or modified is that resources are better utilized when only deduplicating (a) files 200 that are not temporary files that may be deleted soon, and (b) files 200 that have stabilized and are no longer undergoing frequent changes.
At step 710, deduplication module 144 uses the logical range of step 708 to identify files 200 for deduplication. Step 710 is described in detail below by method 800 of FIG. 8.
At step 712, deduplication module 144 performs, for each file identified at step 710, the deduplication method 300 of FIG. 3. Method 300 was described above. After step 712, method 700 ends.
FIG. 8 depicts a flow diagram of a method 800 of identifying files 200 that were modified or recreated during the logical range determined by method 700, according to an embodiment. Method 800 may be performed by deduplication module 144.
At step 802, deduplication module 144 identifies the root directory 502 (e.g., directory 502A of FIG. 5) of file system tree 500. As part of step 802, deduplication module 144 chooses the root directory 502 for further processing and evaluation by method 800.
At step 804, deduplication module 144 determines whether TQ 504 of the current directory 502 contains a timestamp that is within the logical range. If step 804 is reached from step 802, then the current directory 502 is the root directory 502. If step 804 is reached from step 812, then the current directory 502 is one of the child or descendant directories 502 of tree 500.
If TQ 504 of the current directory 502 does not contain a logical timestamp that is within the logical range, then the current directory 502 and all child and descendant directories 502 do not contain files 200 that have been modified or created within the logical range. This means that the current directory 502 and all descendant directories 502 may be skipped for further processing by method 800, and method 800 continues to step 806.
If TQ 504 of the current directory 502 contains a logical timestamp that is within the logical range, then the current directory 502 or a child or descendant directory 502 of current directory 502 may contain at least one file 200 that was modified or created within the logical range. If TQ 504 of the current directory 502 contains a logical timestamp that is within the logical range, then method 800 continues to step 808.
At step 806, deduplication module 144 skips processing all child and descendant directories 502 and files 200 of the current directory 502. In an embodiment, as part of step 806, deduplication module make a record or note of which directory 502 did not contain a logical timestamp within the logical range, and so may be skipped (along with its child and descendant directories 502).
At step 808, deduplication module 144 adds to the list of identified files 200 for deduplication any files 200 located in the current directory 502 that were modified or created within the logical range. As part of step 808, deduplication module 144 determines whether the current directory 502 contains any files 200. If not, then step 808 is skipped. If files are present within the current directory 502, then deduplication module converts the logical range to a real-world time range by accessing time table 172. Deduplication module 144 then checks the modification time of each file 200 within the current directory to determine whether the file 200 has been modified with the real-world and/or logical range. Each file 200 that has been modified within the real-world or logical range is added to the list of identified files for deduplication.
At step 810, deduplication module 144 determines whether more directories 502 remain to be processed by method 800. If not, then method 800 ends. If so, then method 800 continues to step 812. Otherwise, method 800 ends.
At step 812, deduplication module 144 traverses to the next directory 502 within tree 500. The traversal order may be any order appropriate for traversing a tree, such as orders known in the art. For example, tree 500 may be traversed in an “inorder,” “preorder,” or “postorder” manner. After step 812, method 800 returns to directory 804.
It should be understood that, for any process described herein, there may be additional or fewer steps performed in similar or alternative orders, or in parallel, within the scope of the various embodiments, consistent with the teachings herein, unless otherwise stated.
The various embodiments described herein may employ various computer-implemented operations involving data stored in computer systems. For example, these operations may require physical manipulation of physical quantities—usually, though not necessarily, these quantities may take the form of electrical or magnetic signals, where they or representations of them are capable of being stored, transferred, combined, compared, or otherwise manipulated. Further, such manipulations are often referred to in terms, such as producing, identifying, determining, or comparing. Any operations described herein that form part of one or more embodiments of the invention may be useful machine operations. In addition, one or more embodiments of the invention also relate to a device or an apparatus for performing these operations. The apparatus may be specially constructed for specific required purposes, or it may be a general-purpose computer selectively activated or configured by a computer program stored in the computer. In particular, various general-purpose machines may be used with computer programs written in accordance with the teachings herein, or it may be more convenient to construct a more specialized apparatus to perform the required operations.
The various embodiments described herein may be practiced with other computer system configurations including hand-held devices, microprocessor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframe computers, and the like.
One or more embodiments of the present invention may be implemented as one or more computer programs or as one or more computer program modules embodied in one or more computer readable media. The term computer readable medium refers to any data storage device that can store data which can thereafter be input to a computer system—computer readable media may be based on any existing or subsequently developed technology for embodying computer programs in a manner that enables them to be read by a computer. Examples of a computer readable medium include a hard drive, network attached storage (NAS), read-only memory, random-access memory, persistent memory, solid state disk (e.g., a flash memory device), NVMe device, a CD (Compact Discs)—CD-ROM, a CD-R, or a CD-RW, a DVD (Digital Versatile Disc), a magnetic tape, and other optical and non-optical data storage devices. The computer readable medium can also be distributed over a network coupled computer system so that the computer readable code is stored and executed in a distributed fashion.
Although one or more embodiments of the present invention have been described in some detail for clarity of understanding, it will be apparent that certain changes and modifications may be made within the scope of the claims. Accordingly, the described embodiments are to be considered as illustrative and not restrictive, and the scope of the claims is not to be limited to details given herein, but may be modified within the scope and equivalents of the claims. In the claims, elements and/or steps do not imply any particular order of operation, unless explicitly stated in the claims.
Virtualization systems in accordance with the various embodiments may be implemented as hosted embodiments, non-hosted embodiments or as embodiments that tend to blur distinctions between the two, are all envisioned. Furthermore, various virtualization operations may be wholly or partially implemented in hardware. For example, a hardware implementation may employ a look-up table for modification of storage access requests to secure non-disk data.
Certain embodiments as described above involve a hardware abstraction layer on top of a host computer. The hardware abstraction layer allows multiple contexts to share the hardware resource. In one embodiment, these contexts are isolated from each other, each having at least a user application running therein. The hardware abstraction layer thus provides benefits of resource isolation and allocation among the contexts. In the foregoing embodiments, virtual machines are used as an example for the contexts and hypervisors as an example for the hardware abstraction layer. As described above, each virtual machine includes a guest operating system in which at least one application runs. It should be noted that these embodiments may also apply to other examples of contexts, such as containers not including a guest operating system, referred to herein as “OS-less containers” (see, e.g., www.docker.com). OS-less containers implement operating system-level virtualization, wherein an abstraction layer is provided on top of the kernel of an operating system on a host computer. The abstraction layer supports multiple OS-less containers each including an application and its dependencies. Each OS-less container runs as an isolated process in userspace on the host operating system and shares the kernel with other containers. The OS-less container relies on the kernel's functionality to make use of resource isolation (CPU, memory, block I/O, network, etc.) and separate namespaces and to completely isolate the application's view of the operating environments. By using OS-less containers, resources can be isolated, services restricted, and processes provisioned to have a private view of the operating system with their own process ID space, file system structure, and network interfaces. Multiple containers can share the same kernel, but each container can be constrained to only use a defined amount of resources such as CPU, memory and I/O. The term “virtualized computing instance” as used herein is meant to encompass both VMs and OS-less containers.
Many variations, modifications, additions, and improvements are possible, regardless the degree of virtualization. The virtualization software can therefore include components of a host, console, or guest operating system that performs virtualization functions. Plural instances may be provided for components, operations or structures described herein as a single instance. Boundaries between various components, operations and data stores are somewhat arbitrary, and particular operations are illustrated in the context of specific illustrative configurations. Other allocations of functionality are envisioned and may fall within the scope of the invention(s). In general, structures and functionality presented as separate components in exemplary configurations may be implemented as a combined structure or component. Similarly, structures and functionality presented as a single component may be implemented as separate components. These and other variations, modifications, additions, and improvements may fall within the scope of the appended claim(s).

## Claims

1. A method of deduplicating one or more files within a storage system, the one or more files organized within a tree of directories, the method comprising:
modifying or creating a first file at a first time, wherein the first file is located within a first directory and is a child of the first directory;
responsive to the modifying or creating the first file, (a) marking the first directory with a timestamp associated with the first time, and (b) marking with the timestamp each parent directory of the first directory that is not already marked with the timestamp; and
deduplicating the one or more files, wherein deduplicating the one or more files comprises:
traversing the tree of directories from parent to child starting at a root to identify directories of the tree of directories marked with a corresponding timestamp within a determined time range, wherein the determined time range comprises a start time prior in time than the first time and an end time later in time than the first time;
while traversing, locating at least one directory not marked with a corresponding timestamp within the determined time range;
skipping traversing at least one child directory of the at least one directory;
searching within the identified directories to identify files modified or created during the determined time range, wherein the identified files comprise the first file; and
deduplicating the identified files.

2. The method of claim 1, wherein directories of the tree of directories other than the identified directories are not searched to identify files modified or created during the determined time range.

3. The method of claim 1, further comprising:
maintaining a logical clock comprising a counter, wherein each value of the logical clock maps to an actual time, wherein timestamps of directories indicate a value with respect to the logical clock.

4. The method of claim 3, further comprising responsive to the modifying or creating the first file, setting a modification time of the first file to a current actual time, wherein files modified or created during the determined time range comprise files with a corresponding modification time within the determined time range.

5. The method of claim 1, wherein the start time of the determined time range comprises a current time such that the determined time range comprises a time range excluding a time period between a previous time and the current time.

6. The method of claim 1, wherein marking with the timestamp each parent directory of the first directory that is not already marked with the timestamp comprises:
traversing the tree of directories from child to parent starting at the first directory and terminating traversing if a directory that is marked with the timestamp is reached.

7. The method of claim 1, wherein deduplicating the one or more files further comprises:
determining the determined time range, where the determined time range comprises:
a time range later in time than a previous time range used for a previous deduplication, when the one or more files were previously deduplicated, or
any time range, when the one or more files were not previously deduplicated.

8. A non-transitory computer readable medium comprising instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations for deduplicating one or more files within a storage system, the one or more files organized within a tree of directories, the operations comprising:
modifying or creating a first file at a first time, wherein the first file is located within a first directory and is a child of the first directory;
responsive to the modifying or creating the first file, (a) marking the first directory with a timestamp associated with the first time, and (b) marking with the timestamp each parent directory of the first directory that is not already marked with the timestamp; and
deduplicating the one or more files, wherein deduplicating the one or more files comprises:
traversing the tree of directories from parent to child starting at a root directory to identify directories of the tree of directories marked with a corresponding timestamp within a determined time range, wherein the determined time range comprises a start time prior in time than the first time and an end time later in time than the first time;
while traversing, locating at least one directory not marked with a corresponding timestamp within the determined time range;
skipping traversing at least one child directory of the at least one directory;
searching within the identified directories to identify files modified or created during the determined time range, wherein the identified files comprise the first file; and
deduplicating the identified files.

9. The non-transitory computer readable medium of claim 8, wherein directories of the tree of directories other than the identified directories are not searched to identify files modified or created during the determined time range.

10. The non-transitory computer readable medium of claim 8, wherein the operations further comprise:
maintaining a logical clock comprising a counter, wherein each value of the logical clock maps to an actual time, wherein timestamps of directories indicate a value with respect to the logical clock.

11. The non-transitory computer readable medium of claim 10, wherein the operations further comprise responsive to the modifying or creating the first file, setting a modification time of the first file to a current actual time, wherein files modified or created during the determined time range comprise files with a corresponding modification time within the determined time range.

12. The non-transitory computer readable medium of claim 8, wherein the start time of the determined time range comprises a current time such that the determined time range comprises a time range excluding a time period between a previous time and the current time.

13. The non-transitory computer readable medium of claim 8, wherein marking with the timestamp each parent directory of the first directory that is not already marked with the timestamp comprises:
traversing the tree of directories from child to parent starting at the first directory and terminating traversing if a directory that is marked with the timestamp is reached.

14. The non-transitory computer readable medium of claim 8, wherein deduplicating the one or more files further comprises:
determining the determined time range, where the determined time range comprises:
a time range later in time than a previous time range used for a previous deduplication, when the one or more files were previously deduplicated, or
any time range, when the one or more files were not previously deduplicated.

15. A computer system comprising:
one or more processors; and
at least one memory, the one or more processors and the at least one memory configured to:
modify or create a first file at a first time, wherein the first file is located within a first directory and is a child of the first directory;
responsive to the modifying or creating the first file, (a) mark the first directory with a timestamp associated with the first time, and (b) mark with the timestamp each parent directory of the first directory that is not already marked with the timestamp; and
deduplicate one or more files, wherein to deduplicate comprises to:
traverse a tree of directories from parent to child starting at a root directory to identify directories of the tree of directories marked with a corresponding timestamp within a determined time range, wherein the determined time range comprises a start time prior in time than the first time and an end time later in time than the first time;
while traversing, locate at least one directory not marked with a corresponding timestamp within the determined time range;
skip traversing at least one child directory of the at least one directory;
search within the identified directories to identify files modified or created during the determined time range, wherein the identified files comprise the first file; and
deduplicate the identified files.

16. The computer system of claim 15, wherein directories of the tree of directories other than the identified directories are not searched to identify files modified or created during the determined time range.

17. The computer system of claim 15, wherein the one or more processors and the at least one memory are further configured to:
maintain a logical clock comprising a counter, wherein each value of the logical clock maps to an actual time, wherein timestamps of directories indicate a value with respect to the logical clock.

18. The computer system of claim 17, wherein the one or more processors and the at least one memory are further configured to, responsive to the modifying or creating the first file, set a modification time of the first file to a current actual time, wherein files modified or created during the determined time range comprise files with a corresponding modification time within the determined time range.

19. The computer system of claim 15, wherein the start time of the determined time range comprises a current time such that the determined time range comprises a time range excluding a time period between a previous time and a current time.

20. The computer system of claim 15, wherein to deduplicate the one or more files further comprises to:
determine the determined time range, where the determined time range comprises:
a time range later in time than a previous time range used for a previous deduplication, when the one or more files were previously deduplicated, or
any time range, when the one or more files were not previously deduplicated.