JP6048976B2 - Method, computer program, and apparatus for deleting a relationship between a source and a space efficient target in a multi-target architecture - Google Patents

Description

The present invention relates to data replication, and more specifically, point-in-time copies of data (hereinafter “ point-in-time copies ” while minimizing data duplication). And an apparatus for producing the same.

  Data replication features such as IBM® FlashCopy®, Hitachi ShadowImage, etc. can be used to generate nearly simultaneous point-in-time copies of logical volumes or data sets. Among other applications, these point-in-time copies can be used for disaster recovery and business continuity purposes. In particular, IBM® FlashCopy® creates a point-in-time copy by establishing (or “mapping”) a relationship between a source volume and a target volume. Once this relationship is established, data can be read from either the source volume or the target volume. The target bitmap associated with the target volume keeps track of which data tracks were actually copied from the source volume to the target volume. In some cases, the volumes can be placed in a cascade configuration so that a volume functions as both a target and a source. In other cases, the volumes can be placed in a flat (or “multi-target”) configuration such that the source volume has a relationship with multiple target volumes.

  Nevertheless, if the number of volumes increases in either a cascade or multi-target configuration, I / O performance can be significantly affected. For example, in a cascaded configuration, writing to the source volume may need to wait until data is copied between the various volumes in the cascade and writing can be performed. Therefore, the greater the number of volumes in the cascade, the more copies must be performed before data can be written to the source volume. Similarly, in a multi-target configuration, writing to the source volume may need to wait until the data is copied to each connected target and writing can be performed. The more volumes in a multi-target configuration, the more copies that need to be performed before data can be written to the source volume. This can make writing to the source volume very slow. For this reason, current FlashCopy® implementations allow only a limited number of targets in a multi-target configuration in order to maintain performance impact within acceptable limits.

  In view of the above, there is a need for a method for reducing the performance impact of having multiple volumes in a cascade or multi-target configuration. For example, there is a need for a method for reducing data replication in a cascade or multi-target configuration when performing reads and writes. Furthermore, there is a need for a method for efficiently deleting relationships within a cascade or multi-target configuration. Therefore, there is a need in the art to address the aforementioned problems.

  The present invention has been developed in response to state of the art, specifically in response to problems and needs in the art that have not yet been fully solved by currently available methods. Accordingly, an object of the present invention is to provide a method, apparatus, computer program product, and computer program for removing the relationship between a source and a space-efficient (SE) target in a multi-target architecture. Is to provide. The features and advantages of the invention will become more fully apparent from the following description and appended claims, or may be learned by the practice of the invention as set forth hereinafter.

  Consistent with the above, a method is disclosed for deleting a relationship between a source and a target in a multi-target architecture. A multi-target architecture includes a source and a plurality of spatially efficient (SE) targets mapped to the source. In one embodiment, such a method includes initially identifying relationships for deletion from the multi-target architecture. Next, the space efficient (SE) target associated with the relationship is identified. The mapping structure maps the data in the logical track of the SE target to the physical track of the repository. The method then identifies sibling SE targets that inherit data from the SE target. Once the SE target and sibling SE target are identified, the method modifies the mapping structure so that the data in the physical track of the repository is mapped to the logical track of the sibling SE target. Next, the relationship between the source and the SE target is deleted.

  Viewed from a first aspect, the present invention provides a method for eliminating a relationship between a source and a space efficient (SE) target in a multi-target architecture, wherein the multi-target architecture is a source and source Wherein the method identifies a first relationship for removal from the multi-target architecture, a space efficient (SE) target associated with the first relationship The mapping structure maps the data in the logical track of the SE target to the physical track of the repository, identifies the sibling SE target that inherits data from the SE target, the physical of the repository The data in the track becomes the logical track of the sibling SE target Modifying the mapping structure to mappings, and includes deleting the first relation.

  Viewed from another aspect, the present invention provides a computer program product for removing a relationship between a source and a space efficient (SE) target in a multi-target architecture, where the multi-target architecture is a source And a plurality of SE targets mapped to the source, the computer program product is readable by the processing circuit and for executing by the processing circuit to perform the method for performing the steps of the invention A computer readable storage medium is provided for storing instructions.

  Viewed from another aspect, the present invention is stored on a computer readable medium that includes software code portions for performing the steps of the present invention when the program is executed on a computer. A computer program that can be loaded into an internal memory is provided.

  Viewed from another aspect, the present invention provides an apparatus for removing a relationship between a source and a space efficient (SE) target in a multi-target architecture, wherein the multi-target architecture is With a plurality of mapped SE targets, the apparatus has an identification component for identifying the first relationship for removal from the multi-target architecture and a space efficient associated with the first relationship (SE) An identification component operable further to identify a target, wherein the mapping structure maps the data in the logical track of the SE target to the physical track of the repository, and the data from the SE target Identification configuration further operable to identify inherited sibling SE targets It comprises a hydrogen, a modified component for modifying the mapping structure to map the data in the physical tracks repositories logical track sibling SE target, and a deletion component for deleting the first relation.

  Viewed from another aspect, the present invention provides a method for performing a write to a target volume (target x) in a multi-target architecture, wherein the multi-target architecture includes a source volume and a source volume. With a plurality of mapped target volumes, the method is to determine whether the target x has the nearest older sibling (COS), where the COS is the target established immediately before target x If it is a volume, if a target bit map (TBM) for each of target x and COS is set, and if a TBM for both COS and target x is set, C from higher source (HS) volume Copy data to S, if TBM for COS is set and TBM for target x is not set, copy data from target x to COS, and write to target x including.

Viewed from another aspect, the present invention provides a method for performing a read on a target volume (target x) in a multi-target architecture, wherein the multi-target architecture includes a source volume and a source volume. With a plurality of mapped target volumes, the method reads a target bit map (TBM) associated with target x, determines whether the TBM is set, the TBM is set If reading data from a higher source (HS) volume, where reading data from the HS volume is to find the source volume associated with target x, the number of generations on the source volume (GN ) By inspecting Next to the young (hereinafter, "the next younger" called) (next younger) with respect to get x to find the brothers, and, if the TBM associated with the brothers of the next younger has not been set, the next younger Includes reading data from siblings.

  Viewed from another aspect, the present invention provides a method for performing a write to a source volume in a multi-target architecture, wherein the multi-target architecture is mapped to a source volume and a source volume. And copying the data in the track of the source volume to the target volume (target x) mapped to the source volume, at least one sibling mapped to the source volume Including allowing the target volume (siblings) to inherit data from target x and performing writing to the tracks of the source volume.

  Viewed from another aspect, the present invention provides a method for deleting a relationship between a source and a target in a multi-target architecture, wherein the multi-target architecture includes a plurality of targets mapped to the source and the source. And the method identifies a first relationship for deletion from the multi-target architecture, identifies a target associated with the first relationship, identifies a sibling target that inherits data from the target Copying data from the target to the sibling target and deleting the first relationship.

  The present invention will now be described by way of example only with reference to preferred embodiments as shown in the following drawings.

1 is a high-level block diagram illustrating an example of a network architecture with various types of storage systems in which a preferred embodiment of the present invention can be implemented, according to the prior art. FIG. 1 is a high-level block diagram illustrating an example storage system of a method in which a preferred embodiment of the present invention can be implemented, according to the prior art. FIG. FIG. 3 is a high level block diagram illustrating an example of a multi-target architecture with source volumes mapped to multiple target volumes, in accordance with a preferred embodiment of the present invention. FIG. 6 is a high level block diagram illustrating one embodiment of a method for reading a track from a target volume, in accordance with a preferred embodiment of the present invention. 3 is a flow diagram illustrating one embodiment of a method for copying a data track in response to writing to a source volume, in accordance with a preferred embodiment of the present invention. 4 is a flow diagram illustrating one embodiment of a method for copying a data track in response to writing to a target volume, in accordance with a preferred embodiment of the present invention. 4 is a flow diagram illustrating one embodiment of a method for locating a higher source (HS) volume in response to reading to a volume, in accordance with a preferred embodiment of the present invention. 3 is a flow diagram illustrating one embodiment of a method for locating a higher source (HS) volume in response to writing to a volume, in accordance with a preferred embodiment of the present invention. FIG. 3 is a high-level diagram illustrating an example of a multi-target architecture showing the use of generated numbers, in accordance with a preferred embodiment of the present invention. 10 is a table showing data and TBM volumes for the volume shown in FIG. 9 after various writes have been performed, in accordance with a preferred embodiment of the present invention. 10 is a table showing data and TBM volumes for the volume shown in FIG. 9 after various writes have been performed, in accordance with a preferred embodiment of the present invention. FIG. 6 is a high-level block diagram illustrating deletion of a relationship between a source volume and a target volume, in accordance with a preferred embodiment of the present invention. FIG. 6 is a high-level block diagram illustrating deletion of a relationship between a source volume and a space efficient (SE) target volume, in accordance with a preferred embodiment of the present invention. FIG. 4 is a high level block diagram illustrating source and target relationship entries in memory, in accordance with a preferred embodiment of the present invention. 4 is a flow diagram illustrating one embodiment of a method for deleting a relationship between a source and an SE target in a multi-target architecture according to a preferred embodiment of the present invention. 6 is a flow diagram illustrating one embodiment of a method for processing a deleted relationship, in accordance with a preferred embodiment of the present invention. 6 is a flow diagram illustrating another embodiment of a method for processing a deleted relationship according to a preferred embodiment of the present invention.

  It will be readily appreciated that the components of the present invention can be arranged and designed in a wide variety of different configurations, as generally described and illustrated in the drawings herein. Accordingly, the following more detailed description of preferred embodiments of the invention as depicted in the drawings is not intended to limit the scope of the invention, as claimed, but in accordance with the invention. It is merely representative of certain examples of presently contemplated preferred embodiments. The described embodiments will be best understood by referring to the drawings, wherein like parts are designated by like numerals throughout.

  As will be appreciated by one skilled in the art, the present invention may be embodied as an apparatus, system, method, or computer program product. In addition, the present invention may include hardware embodiments, software embodiments configured to operate hardware (including firmware, resident software, microcode, etc.), or all herein as “modules” or “ It can take the form of an embodiment that combines aspects of software and hardware, sometimes referred to as a “system”. Furthermore, the present invention may take the form of a computer-usable storage medium embodied in any tangible representation medium having computer-usable program code stored therein.

  Any combination of one or more computer-usable or computer-readable storage media may be utilized to store the computer program product. The computer-usable or computer-readable storage medium can be, for example but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device. More specific examples (non-exhaustive list) of computer readable storage media are electrical connections with one or more wires, portable computer diskettes, hard disks, random access memory (RAM) Including read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CDROM), optical storage device, or magnetic storage device Can do. In the context of this document, a computer-usable or computer-readable storage medium may contain, store or transport programs for use by or in connection with an instruction execution system, apparatus, or device. Can be any media.

  Computer program code for implementing the operations of the present invention includes object-oriented programming languages such as Java®, Smalltalk, C ++, and conventional procedural programming languages such as the “C” programming language or similar programming languages. Can be created in any combination of one or more programming languages. Computer program code for implementing the present invention can also be created in a low level programming language such as assembly language. The program code may be entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or completely It can be executed on a remote computer or server. In the latter scenario, the remote computer can be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or (eg, the Internet Can connect to an external computer (via the Internet using a service provider). Java® and all Java-based trademarks and logos are trademarks or registered trademarks of Oracle Corporation and / or its affiliates.

  The present invention may be described below with reference to flowchart illustrations and / or block diagrams of methods, apparatus, systems and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions or code. These computer program instructions provide a means for instructions executed via a processor of a computer or other programmable data processing device to implement the functions / operations specified in the flowcharts and / or block diagrams. As created, it can be provided to a processor of a general purpose computer, an application specific computer, or other programmable data processing device for generating machines.

  Computer program instructions that can direct a computer or other programmable data processing device to function in a particular manner can be stored in a computer readable storage medium, resulting in computer readable storage. • Instructions stored in the media generate a product that includes instruction means that implement the functions / operations specified in the flowcharts and / or block diagrams. The result is that the computer program instructions can also be loaded on a computer or other programmable data processing device to cause a series of operational steps to be executed on the computer or other programmable device to generate a computer-implemented process. As such, instructions executing on a computer or other programmable device provide a process for implementing the functions / operations specified in the flowcharts and / or block diagrams.

  Referring to FIG. 1, an example network architecture 100 is shown. The network architecture 100 is presented to illustrate an example environment in which the point-in-time copy method according to the present invention can be implemented. Network architecture 100 is presented by way of example only, and not limitation. Indeed, the methods disclosed herein are applicable to a wide variety of different computers, servers, storage devices, and network architectures in addition to the network architecture 100 illustrated.

  As shown, the network architecture 100 includes one or more computers 102, 106 interconnected by a network 104. The network 104 may include, for example, a local area network (LAN) 104, a wide area network (WAN) 104, the Internet 104, an intranet 104, and the like. In certain embodiments, computers 102, 106 may include both client computer 102 and server computer 106 (also referred to herein as “host system” 106). In general, client computer 102 initiates a communication session while server computer 106 waits for a request from client computer 102. In some embodiments, computer 102 and / or server 106 are connected to one or more internal or external direct attached storage systems 112 (eg, an array of hard disk drives, solid state drives, tape drives, etc.). Is possible. These computers 102, 106 and direct-attached storage system 112 can communicate using protocols such as ATA, SATA, SCSI, SAS, Fiber Channel. One or more of the storage systems 112 can utilize the point-in-time copy method disclosed herein.

  In some embodiments, the network architecture 100 can include a storage network 108 behind the server 106, such as a storage area network (SAN) 108 or a LAN 108 (eg, when using network attached storage). . This network 108 may include one or more of an array 110a of hard disk drives or solid state drives, a tape library 110b, individual hard disk drives 110c or solid state drives 110c, a tape drive 110d, a CD-ROM library, etc. The server 106 can be connected to a plurality of storage systems 110. Host system 106 may communicate via a physical connection from one or more ports on host 106 to one or more ports on storage system 110 to access storage system 110. it can. The connection can be via a switch, fiber, direct connection, etc. In some embodiments, server 106 and storage system 110 may communicate using a networking standard such as Fiber Channel (FC). One or more of the storage systems 110 may utilize the point-in-time copy method disclosed herein.

  Referring to FIG. 2, one embodiment of a storage system 110b that includes an array of hard disk drives 204 or solid state drives 204 or both is shown. In one embodiment, the point-in-time copy method disclosed herein can be implemented in such a storage system 110b, so that the internal components of the storage system 110b are shown, but the method may be used for other storage systems. It can also be applied to the system 110. As shown, the storage system 110b includes a storage controller 200, one or more switches 202, and a hard disk drive 204 or solid state drive 204 (such as a flash memory based drive 204). One or more storage devices 204. The storage controller 200 enables access to data in one or more storage devices 204 of one or more hosts 106 (eg, open systems and / or mainframe servers 106). be able to.

  In selected embodiments, the storage controller 200 includes one or more servers 206. The storage controller 200 can also include a host adapter 208 and a device adapter 210 to connect the storage controller 200 to the host device 106 and the storage device 204, respectively. Multiple servers 206a, 206b can provide redundancy to ensure that the connected host 106 is always available for data. Thus, if one server 206a fails, the other server 206b receives the I / O load of the failed server 206a to ensure that I / O can continue between the host 106 and the storage device 204. To do. This process is sometimes referred to as “failover”.

  An example of a storage system 110b having an architecture similar to that shown in FIG. 2 is the IBM DS8000® enterprise storage system. The IBM DS8000 (R) is a high performance, high capacity storage controller that provides disk storage designed to support continuous operation. Nevertheless, the methods disclosed herein are not limited to the IBM DS8000® enterprise storage system 110b, and are not limited to the manufacturer, product name, or component or component name associated with the system 110. Regardless, it can be implemented in any equivalent or similar storage system 110. Moreover, any storage system that can benefit from one or more preferred embodiments of the present invention is considered to be within the scope of the present invention. Accordingly, the IBM DS8000 is presented as an example only and is not intended to be limiting. IBM, FlashCopy, DS8000 is a trademark of International Business Machines Corporation, registered worldwide in many jurisdictions.

  In selected embodiments, each server 206 may include one or more processors 212 and memory 214. The memory 214 may include volatile memory (eg, RAM) as well as non-volatile memory (eg, ROM, EPROM, EEPROM, hard disk, flash memory, etc.). In certain embodiments, volatile and non-volatile memory may store software modules that execute on the processor 212 and are used to access data in the storage device 204. Server 206 may host at least one instance of these software modules. These software modules can manage all read and write requests to the logical volumes in the storage device 204.

  In selected embodiments, memory 214 includes cache 218. A host 106 (eg, an open system or mainframe server 106) performs a read operation, and the server 206 performing the read fetches data from the storage device 204 in the event that this is needed again, It can be stored in the cache 218. If the data is requested again by the host 106, the server 206 can fetch data from the cache 218 instead of fetching it from the storage device 204, saving both time and resources. Similarly, if the host 106 performs a write, the server 106 that receives the write request can store the write in its cache 218. The server 106 can then destage writing to the storage device 204 if time and resources allow.

  Referring to FIG. 3, an example of a multi-target architecture 300 for creating a point-in-time copy is shown. Such an architecture 300 can be implemented in a storage system 110, such as the storage system 110b shown in FIG. As shown, the multi-target architecture 300 includes a source volume 302 and one or more target volumes 304a-d. Each of the target volumes 304a-d includes a point-in-time copy of the data in the source volume 302. In selected embodiments, such as a FlashCopy® implementation, the point-in-time copy is created by establishing (or “mapping”) a relationship between the source volume 302 and the target volume 304. Once this relationship is established, data can be read from either the source volume 302 or the target volume 304 even if the data still cannot be copied from the source volume 302 to the target volume 304. A target bitmap (TBM) 306 associated with the target volume 304 tracks which data tracks were actually copied from the source volume 302 to the target volume 304. For example, a “0” in the TBM 306 can indicate that the data track has been copied (ie, the target volume 304 has its own data), but a “1” indicates that the data track is still being copied. It can be shown that there is not. If the TBM 306 contains “1”, reads to the track on the target volume 304 can be directed to the corresponding track on the source volume 302. In this disclosure, a bit in TBM 306 is said to be “set” if it contains “1” and “reset” if it contains “0”, which is the opposite in other embodiments. there is a possibility. Although source 302 and target 304 are labeled “volume” in the illustrated embodiment, it should be understood that source 302 and target 304 may be a data set or other collection of data.

  As described above, in the conventional multi-target architecture 300, writing to the source volume 302 is such that the data in the source volume 302 is sent to each connected target volume 304a-d that does not contain its own data. It may be necessary to wait until it has been copied (ie destaged) and writing to the source volume 302 can be completed. That is, before a write is performed on the data track of the source volume 302, the existing data track is already included before the data track on the source volume 302 is overwritten. It is necessary to copy to the target volumes 304a to d which are not present. The greater the number of target volumes 304a-d in multi-target architecture 300, the greater the number of copies that need to be executed before data can be successfully written to source volume 302. This can make writing to the source volume 302 very slow. As such, conventional point-in-time copy techniques can support only a limited number (eg, 12) of targets 304 within the multi-target architecture 300 to maintain performance impact within acceptable limits.

  As described in more detail below, the performance of having multiple target volumes 304a-d mapped to a source volume 302 using an improved method in accordance with a preferred embodiment of the present invention. The impact can be reduced. Instead of copying data to multiple targets 304a-d when a write is performed on source volume 302, the improved method copies data to a single target 304 or a subset of targets 304. The inheritance scheme then allows other targets 304 to inherit data from a single target 304 or a subset of targets 304 that contain the data. In this way, writing to source volume 302 may only require copying the data to a single target 304 or a subset of targets 304 before the writing can be completed on source volume 302. it can. The flowcharts shown in FIGS. 4-8 illustrate various specific examples of methods for implementing such methods.

  Referring to FIG. 4, an example method 400 for reading a track from a target volume 304 is shown. Upon receiving a request to read a data track from the target volume 304, the method 400 determines whether the TBM of the target volume 304 has been set (402). If the TBM has not been set (indicating that the target volume 304 contains the requested data), the method 400 simply reads the requested data track from the target volume 304 (406). On the other hand, if the TBM is set (indicating that the target volume 304 does not contain the requested data), the method 400 finds a higher source (HS) volume from which the data is read (404). Read from the HS volume (404). One method 700 for finding an HS volume is described in connection with FIG. In the present disclosure, the HS volume is the inheritance source volume of the target volume 304 including the requested data.

  Referring to FIG. 5, one embodiment of a method 500 for destaging a data track in response to writing to a source volume 302 is shown. As shown, the method 500 initially finds the youngest child (YC) of the source volume 302 (502). In this disclosure, YC is the target volume 304 that was last mapped to the source volume 302. In selected embodiments, the generation number (GN) can be used to identify the order in which the target volume 304 was added to the source volume 302 to generate a point-in-time copy. The manner in which GN is used to determine the order in which targets 304 are mapped to source volumes 302 is discussed in connection with FIG.

  If the method 500 finds YC, it determines if the YC TBM is set (504). If the TBM is not set (indicating that YC 304 contains a copy of its own data), method 500 does nothing (508) because YC 304 already has a copy of the data. On the other hand, if the TBM is set (indicating that YC 304 does not contain a copy of its own data), method 500 copies data from source volume 302 to YC 304 (506). In this way, when writing to the source volume 302 is performed, the data is simply copied between the source volume 302 and the YC 304 as opposed to copying the data to all target volumes 304 that do not contain data. One copy is executed. Therefore, another target volume 304 (not YC 304) inherits this data from YC 304 when a read to another volume 304 is executed or when data is copied from another volume 304. Can do.

  Referring to FIG. 6, one embodiment of a method 600 for destageing a data track in response to writing to a target volume 304 (target x) is shown. As shown, the method 600 initially determines whether the TBM for the target x 304 and the nearest older sibling (COS) 304 is set for the track being written (602). In the present disclosure, the COS is the target volume 304 mapped immediately before the target x304. If both TBMs are set (indicating that neither volume contains data in the written track), the method 600 copies the data track from the high source (HS) volume to the COS 304 (604). ). The method for finding the HS volume is discussed in connection with FIG. On the other hand, it is determined in step 606 that the TBM for target x is not set and the TBM for COS is set (indicating that target x304 contains data in the overwritten data track). If so, the method 600 copies 608 the data track from the target x to the COS 304, ie, the data track is destaged from the target x 304 to the COS 304. On the other hand, if the COS TBM is not set (indicating that the COS contains data), the COS does not exist and the method 600 does not need to be copied and does nothing (610). When the method 600 reaches the end, a write can be performed on the target x.

  It should be understood that the methods 500, 600 described above can be modified in various ways without departing from the invention. For example, the youngest child (YC) can be replaced with the oldest child, and the nearest older brother (COS) can be replaced with the nearest younger brother. Thus, in this disclosure, embodiments that utilize YC and COS are also considered to encompass embodiments that utilize the oldest child and the nearest younger sibling. Other variations are possible and within the scope of the present invention.

  Referring to FIG. 7, one embodiment of a method 700 for finding an HS volume for reading is shown. Such a method 700 can be used in connection with step 404 of FIG. As shown, the method 700 initially determines whether the volume being read is the target volume 304 (702). If not the target volume 304, the method 700 reads from this volume because it is the source volume 302. If the volume is the target volume 304, the method determines whether the volume's TBM is set (706). If no TBM is set, the method 700 reads from the volume 304 (704). If the TBM for the volume has been set, the method 700 finds the source volume 302 associated with the target volume 304 (708). Next, the method 700 finds the next relationship between the number of generations (GN) of the target target volume 304 and the next highest generation number (GN) (710). The usage of GN will be described in more detail with reference to the example of FIG.

  In general, decision step 710 finds a relationship for the next younger source volume 302 of the relationship associated with the target target volume 304 (identified in step 702). The method 700 then finds a target 304 for this relationship (714). If the TBM for this target 304 is set 716, the method 700 reads from the target 304. If the TBM for this target 304 is not set 716, the method 700 repeats steps 710 and 714 to find the next younger target 304 and determine whether the TBM is set (716). In this way, the method 700 traverses the younger siblings of the target volume 304 identified in step 702 until a target volume 304 containing the desired data is found. If this data is found, method 700 reads from target 304 (718). If a younger sibling target 304 containing the desired data is not found, the method simply reads 712 from the source volume 302. In this manner, the target volume 304 can inherit data from the sibling 304 when reading to the sibling 304 is executed.

  Referring to FIG. 8, one embodiment of a method 800 for finding an HS volume from which data is copied is shown. Such a method 800 can be used in connection with step 604 of FIG. As shown in the figure, the method 800 initially determines whether the write destination volume is the target volume 304. If it is not the target volume 304, copying is not required, as reflected in step 804. If the volume is the target volume 304, the method determines whether a TBM for the volume has been set (806). If no TBM is set, copying is not necessary. If the volume is the target volume 304 and the volume's TBM is set, the method finds the source volume 302 associated with the target volume 304 (808). The method 800 then finds the next relationship with the higher generation number (GN), as described above.

  Upon finding the next highest GN, the method 800 finds a target 304 in this relationship that is a sibling of the target 304 identified in step 802 (814). If the TBM for this sibling target 304 is not set 816 (indicating that it contains the desired data), method 800 copies data from sibling target 304 to COS 304 (818). If the TBM for this sibling target 304 is set 816 (indicating that it does not contain the desired data), the method 800 repeats steps 810, 814 to find the next younger sibling target 304, and that TBM is It is determined whether it is set (816). In this way, the method 800 traverses the younger siblings of the target volume 304 identified in step 802 until a sibling target volume 304 containing the desired data is found. If this data is found, the method 800 copies the data from the sibling target 304 to the COS (818). If no sibling target 304 containing the desired data is found, the method 800 copies data from the source volume 302 to the COS (812). Once the data is copied, writing on the target 304 identified in step 802 can be performed.

  Referring to FIG. 9, an example of a multi-target architecture 300 that illustrates the use of generated number (GN) is shown. In this example, the relationship between the source volume (SV) 302 and the first target volume (TV1) 304a is created first, and then the source volume 302 and the second target volume (TV2). Assume that the relationship between 304b and then the relationship between source volume 302 and third target volume (TV3) 304c has been created. Each time a new relationship is added to the source volume 302, the generation number is incremented. Thus, as shown in the source volume 302, the first relationship is associated with the generation number “1”, the second relationship is associated with the generation number “2”, and the third relationship is the generation number “3”. Associated with

  Initially, the relationship between the source volume 302 and the first and second target volumes 304a, 304b is established, but the relationship between the source volume 302 and the third target volume 304c is still Assume that it has not been established. In this scenario, to perform a write to track 1 of the second target volume 304b, the data in track 1 is transferred from the source volume 302 (higher source) to the first target volume 304a (closest year). The TBM of the first target volume 304a is reset. Thereafter, writing to track 1 of the second target volume 304b is executed, and the TBM of the second target volume 304b is reset. Similarly, to perform a write to track 2 of source volume 302, the data in track 2 is copied from source volume 302 to a second target volume 304b (the youngest child, or YC), The TBM of the second target volume 304b is reset (indicating that it contains data). Thereafter, writing to the track 2 of the source volume 302 is executed. The data resident in the first target volume (TV1) 304a and the second target volume (TV2) 304b after two writes is shown in FIG. The value in the TBM is also shown.

  Here, it is assumed that a third relationship between the source volume 302 and the third target volume 304c is established. To perform a write to track 3 of source volume 302, the data in track 3 is copied from source volume 302 to a third target volume 304c (the youngest child, or YC), and the third The TBM of the target volume 304c is reset. Next, writing to the track 3 of the source volume 302 is executed. To perform a write to track 4 of second target volume 304b, the data in track 4 is transferred from source volume 302 (higher source) to first target volume 304a (closest older brother, In other words, the TBM of the first target volume 304a is reset. Next, writing to the track 4 of the second target volume 304b is executed, and the TBM of the second target volume 304b is reset.

  In order to perform writing to track 5 of the first target volume 304a, no copy is performed because there is no nearest older brother, ie, COS. Next, writing to the track 5 of the first target volume 304a is executed, and the TBM of the first target volume 304a is reset. To perform a write to track 6 of third target volume 304c, the data in track 6 is transferred from source volume 302 (higher source) to second target volume 304b (closest older brother, In other words, the TBM of the second target volume 304b is reset. Next, writing to the track 6 of the third target volume 304c is executed, and the TBM of the third target volume 304c is reset. After all six writes described above, the data residing in the first target volume (TV1) 304a, the second target volume (TV2) 304b, and the third target volume (TV3) 304c is shown in FIG. 11. The value in the TBM is also shown.

  Referring to FIG. 12, in some environments, a relationship between a source volume 302 and a target volume 304, or some relationship between a source volume 302 and several target volumes 304, may be It can be deleted from the architecture 300. If the relationship is deleted from the multi-target architecture 300, the point-in-time relationship between the source volume 302 and the target volume 304 associated with the relationship ends. In some embodiments, this may end the function of other sibling target volumes 304 to inherit data from the target volume 304 whose relationship has been deleted. Thus, in one embodiment, prior to deleting a relationship, data on the target volume 304 associated with the relationship can be copied to one or more sibling target volumes 304, resulting in siblings. Target volume 304 is still accessible to data.

  For example, assume that the relationship between the source volume 302 and the target volume 304c is identified for deletion (as indicated by the dotted arrows). Prior to deleting the relationship, data stored on the target volume 304c and inherited by other sibling target volumes 304 can be copied to one or more sibling target volumes 304, so As a result, sibling target volume 304 is still accessible to the data. For example, in one embodiment, data will be copied to the nearest older sibling (COS), such as when using the point-in-time copy method described in FIGS. Other point-in-time copy methods can be used to copy data to other sibling target volumes 304 other than the COS. Nevertheless, the present disclosure assumes that data is copied to the COS. Once all the data stored in the target volume 304c and inherited by the other sibling target volume 304 is copied to the COS, the relationship between the source volume 302 and the target volume 304c can be deleted, Thereby, the point-in-time copy relationship between the source volume 302 and the target volume 304c ends.

  Referring to FIG. 13, in some cases, the relationship between the source volume 302 and the space efficient (SE) target volume 304 can be deleted. The SE target volume 304 differs from the standard target volume 304 (as shown in FIG. 12) in that no data is physically stored in the volume. Rather, the SE target volume 304 is a virtual volume (as indicated by the dotted line) whose data is physically stored in the common repository 1200. The mapping structure 1202 keeps track of where SE target volume data is physically located in the repository 1200. In other words, the mapping structure 1202 maps the logical track of the SE target volume 304 to the physical track of the repository 1200. From the host device perspective, reading from or writing to the SE target volume 304 can be the same as reading from or writing to the standard target volume. .

  Since the SE target volume 304 does not physically store any data, a physical copy of data from the SE target volume 304 to another sibling SE target volume 304 is not required if the relationship is deleted. Rather, the mapping structure 1202 can be modified so that other sibling SE target volumes, more specifically COS volumes, point to the data of the SE target volumes in the repository 1200. In other words, instead of physically copying data from one SE target volume to another, the data that is logically stored in one SE target volume is stored here so that it can be executed on a standard target volume. Now the mapping structure 1202 can be modified to be logically stored in another SE target volume. For purposes of this disclosure, all target volumes mentioned below are assumed to be space efficient (SE) target volumes.

  Referring to FIG. 14, in one embodiment, a relationship table 1300 is stored in the memory 214 to track each relationship in the multi-target architecture 300. In some embodiments, each relationship associates them with a source relationship entry 1302a corresponding to the source of the relationship and a target relationship entry 1302b corresponding to the target of the relationship. As will be explained in more detail below, when deleting a relationship, the deletion of the relationship is in progress (ie the mapping structure is being modified to map the data to the COS in preparation for deleting the relationship. The source relationship entry 1302a and the target relationship entry 1302b associated with the relationship can be marked as “deleted”. By creating the relationship entries 1302a and 1302b in this way, it is possible to ensure that data is not written to the SE target volume 304 for which deletion of the relationship is in progress. Once the mapping structure is modified so that the data logically stored in the SE target volume is logically stored in the COS, the relationship can be deleted. Deleting a relationship can include deleting a source relationship entry 1302a and a target relationship entry 1302b associated with the relationship from the relationship table 1300.

  Referring to FIG. 15, one embodiment of a method 1400 for deleting the relationship between the source 302 and the SE target 304 in the multi-target architecture 300 is shown. As shown, the method 1400 initially determines 1402 whether a request to withdraw (ie, a request to delete a relationship) has been received. If a withdrawal request is received, the method 1400 marks the relationship entry associated with the relationship as “deleted” (1404). This may include marking 1404 both the source relationship entry 1302a and the target relationship entry 1302b associated with the relationship as “deleted”. The method 1400 then determines whether a relationship is already in progress, ie, whether the mapping structure 1202 is being modified to map data to the COS in preparation for relationship deletion (1406).

  If the relationship is already in progress, the method 1400 queues the relationship (1408). Once the relationships are queued, the method 1400 sorts the relationships in the queue from the oldest to the youngest (1408) to process the older relationships prior to the younger relationships. This ideally minimizes the number of times the mapping structure 1202 is modified. For example, if the mapping structure 1202 is modified to map data to a COS whose relationship is to be deleted, the mapping structure 1202 needs to be modified again, both time and resources are wasted. . Processing the relationship from oldest to youngest helps to ensure that the mapping structure 1202 has been modified a minimum number of times.

  Various methods or techniques can be used to determine the age of the relationship. In some embodiments, the age of the relationship is determined using a generated number as shown in FIG. For example, by examining the number of generations on the source volume 302, the age of the relationship can be easily determined. In the example shown in FIG. 9, the generation number is incremented each time a new relationship is generated. Therefore, the relationship associated with the generation number “1” is the oldest and the relationship associated with the generation number “3” is the youngest. This rule can be reversed in other embodiments.

  If there is no relationship in the queue, the method 1400 simply processes the relationship (1410). If there are one or more relationships in the queue, the method 1400 processes the next relationship in the queue (1410). Various methods for processing (1410) the relationship are described in connection with FIGS. Once the relationship is processed, ie, mapping structure 1202 is modified to map data to COS 304 with respect to SE target 304, method 1400 removes relationship entries 1302a, 1302b associated with the relationship from relationship table 1300. (1412). This ends the relationship. The method then checks 1414 if any other relationships are in the queue. If the queue is empty, the method 1400 waits for the next request to withdraw (1402). If the queue is not empty, the method 1400 processes the next relationship in the queue (1410). This continues until all the relationships in the queue are processed.

  In certain embodiments, the method 1400 is configured to allow some relationships to be in progress at any particular time. In some embodiments, the number of relationships in progress at any particular time may exceed the storage device 204 (eg, disk drive, solid state drive, etc.) or the device adapter 210 associated with the storage device 204. It can be restricted not to overdrive. For example, in one embodiment, device adapter 210 and storage device 204 may be restricted to handle several (eg, four) relationships at any particular time so as not to overdrive the device. If several relationships are being processed simultaneously, priorities can be given priority over newer relationships in order to minimize the number of times the mapping structure 1202 is modified.

  Referring to FIG. 16, an embodiment of a method 1410 for processing relationships is shown. Such a method 1410 can be performed whenever the relationship is processed, as illustrated in FIG. As shown, to process the relationship, method 1410 initially identifies (1500) the SE target associated with the relationship. The method 1410 then identifies the closest older sibling (COS) of the SE target (1502). Next, the method 1410 inspects the SE target and the first track of the COS (1504). Method 1410 determines that the SE target TBM for the track has not been set (indicating that the SE target contains a copy of the data) (1506), and that the COS TBM for the track has been set (COS is Once determined (1508), the method 1410 modifies the mapping structure 1202 to map the data in the repository 1200 to the COS (1510). Next, the COS TBM for the track is reset (1510) to indicate that it contains a copy of the data. However, if the SE target TBM for the track is set (indicating that the SE target does not contain a copy of the data), or if the COS TBM for the track is not set (the COS already contains a copy of the data) The mapping structure 1202 is not modified, and the method 1410 proceeds to decision step 1512.

  If method 1410 examines the track and determines that mapping structure 1202 is modified or no modification is required, method 1410 determines whether the final track of SE target 304 has been reached (1512). If the final track has not been reached, the method 1410 examines (1514) the next track of the SE target and the corresponding track of the COS and repeats steps 1506, 1508, 1510, 1512. If all tracks in the SE target 304 have been examined and if necessary the mapping structure 1202 has been modified for those tracks, the method 1410 ends.

  Referring to FIG. 17, another embodiment of a method 1410 for processing relationships is shown. Such a method 1410 can be performed instead of the method of FIG. 16 whenever the relationship is processed 1410. Using the method 1410 shown in FIG. 17 to address implementations with nearest older siblings (COS) that differ in different ranges of tracks in the SE target, such as data set level point-in-time implementations. it can.

  As shown, to process the relationship, the method 1410 initially identifies (1600) the SE target associated with the relationship and a first track range of SE targets (eg, the first 50 tracks). ) Is identified (1602). The method 1410 then identifies the nearest older sibling (COS) associated with the track range (1604). The method 1410 then examines the first track in the track range and the corresponding track in the COS (1606). Method 1410 determines that a TBM for a track within the track range has not been set (indicating that the track contains a copy of the data) (1608) and a TBM for the corresponding track in the COS has been set ( If it is determined (1610) that the track in the COS does not contain a copy of the data), the method 1410 modifies the mapping structure 1202 to map the data in the repository 1200 to the COS (1620). The TBM for the track in the COS is then reset (1620) to indicate that it now contains a copy of the data. However, the TBM for the track on the SE target is set (indicating that the SE target does not contain a copy of the data) or the COS TBM for the corresponding track is not set (the COS is already a copy of the data The mapping structure 1202 is not modified and the method 1410 proceeds to decision step 1618.

  If method 1410 examines tracks within the track range and determines that mapping structure 1202 is modified or no modification is required, method 1410 determines whether there are other tracks within the track range (1618). . If there are other tracks in the track range, the method 1410 examines the next track in the track range as well as the corresponding track in the COS by repeating steps 1608, 1610, 1620, 1618 (1616). If all tracks within the track range have been examined and if necessary the mapping structure 1202 has been modified for those tracks, the method 1410 determines if there are other track ranges within the SE target (1614). ). If there are other track ranges, the method 1410 identifies 1604 the COS for that track range and repeats steps 1606, 1608, 1610, 1620, 1618, 1616 for the track range and the identified COS. This continues until all tracks within all track ranges of the SE target have been examined and, if necessary, the mapping structure 1202 has been modified for those tracks. Once all tracks within all track ranges of the SE target have been examined and mapping structure 1202 has been modified accordingly, method 1410 ends.

  The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer-usable media in accordance with various preferred embodiments of the present invention. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of code that includes one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions shown in the blocks can be performed out of the order shown in the drawings. Depending on the functions involved, for example, two blocks shown in succession can actually be executed almost simultaneously, or sometimes the blocks can be executed in reverse order. Application-specific hardware-based systems, or application-specific hardware and computers, where each block in the block diagram and / or flow diagram, and combinations of blocks in the block diagram and / or flow diagram, perform the specified function Note also that it can be implemented by a combination of instructions.

Claims (4)

A method for removing a relationship between a source and a space efficient (SE) target in a multi-target architecture, wherein the multi-target architecture is a single source and a plurality of SE targets mapped to the source. And the computer is
Finding a first relationship from the multi-target architecture that maps a point-in-time copy relationship between the source and one SE target;
Finding from the multi-target architecture a space efficient (SE) target associated with the first relationship, wherein data in the logical track of the SE target is physically stored in a repository. And said finding step;
Finding a sibling SE target from the multi-target architecture that is in a point-in-time copy relationship with the source and at a different point in time than the SE target, wherein the sibling SE target Inherit the data from the SE target by copying, the sibling SE target is the SE's closest older sibling (COS) SE target, and the nearest older sibling SE target is the SE target Said finding step, which is the target mapped immediately before
The mapping structure that maps data in the logical track of the SE target to data in the physical track of the repository is modified to map the data in the physical track of the repository to the logical track of the sibling SE target Said modifying step wherein said repository physically stores data of said plurality of SE targets;
Deleting the first relationship from the multi-target architecture, wherein the deleting terminates a point-in-time copy relationship between the source and the SE target; and Performing said method. Modifying the mapping structure comprises:
(1) finding data that is not logically stored in the sibling SE target and logically stored in the SE target;
(2) The mapping structure is such that data that is logically stored in the SE target but not logically stored in the sibling SE target is logically stored in the sibling SE target. The method of claim 1, further comprising: modifying. An apparatus for deleting a relationship between a source and a space efficient (SE) target in a multi-target architecture, the multi-target architecture comprising a single source and a plurality of SE targets mapped to the source And the device comprises:
A first component for finding a first relationship from the multi-target architecture that maps a point-in-time copy relationship between the source and one SE target;
A second component for finding from the multi-target architecture a space efficient (SE) target associated with the first relationship, wherein data in the logical track of the SE target is physically stored in a repository. Said second component being stored in memory,
A third component for finding from the multi-target architecture a sibling SE target that is in a point-in-time copy relationship with the source and at a different point in time than the SE target; An SE target inherits the data from the SE target by copying the data, and the sibling SE target is the nearest older sibling (COS) SE target of the SE target, and the nearest older sibling SE The target is the third component that is the target mapped immediately before the SE target; and
The mapping structure that maps data in the logical track of the SE target to data in the physical track of the repository is modified to map the data in the physical track of the repository to the logical track of the sibling SE target A fourth component for storing, wherein the repository physically stores data of the plurality of SE targets; and
A fifth component for deleting the first relationship from the multi-target architecture, the deletion ends a point-in-time copy relationship between the source and the SE target; The device comprising: the fifth component. A method for removing a relationship between a source and a space efficient (SE) target in a multi-target architecture, wherein the multi-target architecture is a single source and a plurality of SE targets mapped to the source. And the computer is
Finding from the multi-target architecture a first relationship that maps a point-in-time copy relationship between the source and one SE target;
Finding from the multi-target architecture a space efficient (SE) target associated with the first relationship, wherein data in the logical track of the SE target is physically stored in a repository. And said finding step;
Finding a sibling SE target from the multi-target architecture that is in a point-in-time copy relationship with the source and at a different point in time than the SE target, wherein the sibling SE target Inherit the data from the SE target by copying, the sibling SE target is the SE's closest older sibling (COS) SE target, and the nearest older sibling SE target is the SE target Said finding step, which is the target mapped immediately before
Copying the data from the SE target to the sibling SE target;
Performing the step of deleting the first relationship from the multi-target architecture, wherein the deletion terminates a point-in-time copy relationship between the source and the SE target. Said method comprising:

Images