SYSTEM AND METHOD FOR SYNCHRONIZING COPIES OF DATA IN A COMPUTER SYSTEM

Abstract: An improved synchronization system and method for copies of data in a computer system. The computer system comprises a cluster, wherein each computer in the cluster may store a local copy of a data set along with a validity flag for the local copy. The computer system further comprises a coupling system which is connected to each of the computers in the cluster through a coupling system interface program, wherein the coupling system is configured to coordinate the data sharing and workload of the cluster. The computer system also comprises an external data storage shared by the computers in the cluster. One of the computers may read a first copy of the data set from a primary data set on the external data storage. The computer may then store the first copy locally and set a first validity flag to indicate that the first copy is valid. Another computer, server, or application program may make a second copy of the primary data set and set a second validity flag to valid. If the first copy is modified, then the second validity flag is set to invalid. The second copy may then be replaced with the modified copy, and the second validity flag may be set to valid again. A coupling system interface program may comprise an application programming interface for data synchronization, wherein the application programming interface is accessible by a plurality of application programs.

Description: TITLE: SYSTEM AND METHOD FOR SYNCHRONIZING COPIES OF DATA IN A COMPUTER SYSTEM BACKGROUND OF THE INVENTION 1 Field of the Invention The present mvention generally relates to the synchronization of multiple copies of data in a computer system More particularly, the present invention relates to the synchronization of copies of data stored on several computer systems linked together m a cluster 2 Description of the Related Art In a computer program that accesses vaπous forms of data stored on disk or other non- volatile memory, it is often advantageous to store copies of high use data in volatile memory Accessing data from volatile memory is typically much faster than accessmg data from non-volatile memory The process of storing high use data m volatile memory is commonly called caching Large-scale computer applications such as transactional applications used m the financial industry often make use of cachmg for performance reasons These large-scale applications have mcreasmgly demanded more processmg power Early mainframe computer systems typically contamed one processor, one volatile memory, and arrays of non- volatile memory such as disk and tape Later, multiple-processor systems were introduced which provide a significant performance boost over smgle-processor systems One type of multiple-processor system is a Symmetric Multiprocessor system (SMP) An SMP compπses a set of processors that shares a number of common components, mcludmg volatile memory SMPs offer significant performance advantages over smgle-CPU systems, and SMPs are scalable by addmg additional processors A major disadvantage of SMPs, however, is that significant resources must be dedicated to synchronizing the activities of the processors A pomt may be reached at which addmg additional processors actually decreases overall performance Furthermore, m addition to the processmg and scalability limitations, multiple-processor systems share a weakness with smgle-processor systems when the system experiences planned or unplanned downtime, the processmg services provided by the system are unavailable The demand for processmg performance and scalability greater than that provided by multiple-processor systems and the demand for mcreased availability led to the development of clusters In general, a cluster is a group of servers that can share resources and cooperate m processmg Clusters may be categorized mto three general types The first type is a high-availability cluster In a high-availability cluster, one server is typically the primary server and a second server is typically the backup server If the primary server becomes unavailable due to failure or other reasons, processmg is transferred to the backup server In order to provide as seamless a transition as possible, the backup server is commonly kept m an idle state, negatively impacting the price-performance ratio of the system High-availability clusters mcrease the availability of computing resources, but they do not provide significantly greater performance than earlier systems A second cluster type is the parallel cluster Parallel clusters include two or more servers that share some resources, work may be split among the servers and performed m parallel The servers in the cluster appear as multiple logical systems to the client Duπng processmg, programs and data may be partitioned among the servers The partitioning of program workload and data among the servers is difficult to manage No smgle server has access to all of the data Addmg additional servers to the cluster requires repartitioning of the workload and data Unbalanced workloads or data may overload one or more servers while other servers are underutilized If a server fails, its workload must be passed to a backup server to maintain availability. This can be detrimental to performance if the backup server has a workload of its own or has a slow access path to the failed server's data. The third cluster type is the single-system image cluster. The servers in a single-system image cluster appear as one logical system to clients and to application programs running on the cluster, hence the name "single- system." All servers in the cluster have access to all of the data, and any server in the cluster may run any transaction. Copies of a program may run concurrently on several servers in the cluster. The workload may be dynamically distributed among the servers. The single-system image cluster solves the availability and scalability problems and adds a level of stability by the use of redundant systems with no single points of failure. Effectively, the one logical system may be available year-round to clients and application programs without any outages. Hardware and software maintenance and upgrades may be performed without the loss of availability of the cluster and with little or no impact to active programs. The combination of availability, scalability, processing capability, and the logical system image make the single-system image cluster a powerful environment on which to base a large-scale transaction-based enterprise server. Single-system image clusters typically share external non- volatile data storage, such as disk drives. Databases and other types of data permanently reside on the external storage. The servers, however, do not generally share volatile memory. Each server in the cluster operates in a dedicated local memory space. As mentioned above, copies of a program may reside on several servers, and the programs may appear as one program to the client. Workload is distributed among the copies of the program. The programs may access shared data from external storage. For performance advantages, each program may cache high-use data in local memory space. A single-system image cluster may include at least one Coupling Facility (CF) which provides hardware and software support for the cluster's data sharing functions. Typically, a CF may provide data synchronization for proprietary database architectures such as VSAM, IMS, and DB2, but a CF usually does not provide an application programming interface (API) to allow third-party application programs to directly access the data synchronization functions of the CF. Because of the lack of an API, the CF's data synchronization capabilities cannot be easily applied to data architectures other than the a handful of proprietary architectures listed above. The single-system image cluster may also provide a timer facility to maintain time synchronization among the servers. On a single-system image cluster, several operating system images such as MVS images may be running on at least one computer system. MVS and OS/390 are examples of mainframe operating systems. OS/390 is a newer version of the MVS operating system, and the terms OS/390 and MVS are used interchangeably herein. "MVS image" is used synonymously with "server" herein. Operating systems other than MVS may also run as servers on a single-system image cluster. Each server is allocated its own local memory space. The servers appear as one logical server to a client. Programs may be dup eated in the memory space of several servers. The workload of a program may be divided among several copies of the program running on different servers. The data required by the program is stored on shared non- volatile memory. A copy of the program may cache frequently used portions of the shared data in a local memory space. As in the case with the multiple servers appearing as one logical server, multiple copies of a program running on a single-system image cluster may appear as one logical program to the client. The caching of copies of data in local memory areas by programs running on servers in a cluster may lead to a problem in a single-system image cluster environment. If copies of a program require the same data, each may cache a copy in local memory. If one copy of the program modifies a local copy of the data and, optionally, the base data on the external storage, copies of the data cached on other servers are no longer concurrent with the modified copy. It is therefore desirable to provide a method of efficient, timely, and reliable synchronizanon of data in a single-system image cluster environment It is also desirable to provide an API to the coupling facility to allow software developers to make source code calls to the functions of the coupling facility, and to enforce data synchronization for data architectures other than proprietary datbases The problem of data synchronization may also occur in computer systems m general where a program or programs make copies of shared data Therefore, a solution to the data synchronization problem should preferably be applicable to computer systems m general as well as specifically to smgle-system image cluster systems. SUMMARY OF THE INVENTION The present mvention provides vaπous embodiments of an unproved method and system for synchronizing copies of data in a computer system. In one embodiment, a program executing on a server maintains a list of data structures wherein one data structure is allocated to each copy of a primary data set that is read into volatile memory by the program, and wherem a data structure may be used to record the validity of a copy of the primary data. The term "validity" as used herem refers to the state of copies of a primary data set m compaπson to the primary data set. If a copy of a data set is valid, the copy of the data set is concurrent with the primary data set. If a copy of a data set is invalid, the primary data set has been modified so that the copy of the data set is not concurrent with the primary data set. "Primary data set" is used herem to descπbe a groupmg of data elements that may be stored m a memory medium external to the servers' local memory, and that may be shared among programs running on servers m the cluster In one embodiment, a primary data set may be a groupmg of records extracted from a database stored on disk. In one embodiment, a primary data set may be constructed from multiple sources on a data storage, wherein the data m the data set may not have a one-to-one correspondence to a physical data set in a database. In some embodiments of a database, records of the database may include at least one field mcludmg a unique identifier, or key, which is used to identify and locate copies of the records. As a copy of a primary data set is created, a validity data structure may be assigned to the copy from the list and a field m the data structure may be initialized to mdicate the copy is valid. The field may be referred to as a validity flag, and may have two states: valid and invalid. A flag set to valid mdicates that the associated copy of the data set is synchronized with other copies of the data set; a flag set to invalid mdicates that at least one other copy of the data set has been modified smce the associated copy of the data set was last updated The program may keep track of which data structure m the list is assigned to a copy of the data set. In one embodiment, the list of data structures may be a section of memory wherein each bit of the memory location serves as a validity data structure, and wherem a bit set to "0" may mdicate that the copy is valid and a bit set to "1" may mdicate that the data copy is invalid. In another embodiment, a data structure may comprise a plurality of bytes wherem each byte serves as a validity data structure. In yet another embodiment, the validity data structure may be a collection of fields, wherem a first field mcludes a memory address or some other link to the data set copy used by the program to associate the validity flag with the data set copy, and a second field mcludes the vahdity flag. In one embodiment, the validity data structure may be internally allocated m the program's memory space. In another embodiment, the vahdity data structure may exist m memory external to the program. In yet another embodiment, the data structure may be maintained m hardware, such as a set of registers, for example. In one embodiment, when a program modifies a copy of a data set, the primary data set may be replaced with the modified copy. The validity flags of other copies of the data set may then be set to invalid. When a program needs to access a copy of the data set, the associated validity flag may be checked for validity of the data set. If the flag is valid, the second copy of the data set may be accessed directly by the program. If the flag is invalid, the second copy of the data set may be synchronized before access by overwriting with the contents of the primary data set The program may then set the validity flag for the second data set copy to valid In one embodiment, one or more distinct primary data sets may be copied by one or more programs In one embodiment, one list of data structures may be maintained for copies of all distinct data sets. In another embodiment, one list may be mamtamed for copies of each distinct data set. In one embodiment, more than one program may be running on the computer system, the programs may be sharing at least one data set, and the vahdity data structure list may be mamtamed in memory external to the programs A synchronization program may perform the management of the synchronization of data sets The synchronization program may assign a validity data structure to each copy of a data set the programs cache m local memory When a first program modifies a local copy of a data set, the first program may replace the primary data set with the modified copy and notify the synchronization program that the data set has been modified The synchronization program may then set the validity flags of all cached copies of the modified data set to invalid. In one embodiment, when a second program requires access to a local cached copy, the second program may directly check the validity flag. In another embodiment, the second program may request the synchronization program to check the status of the validity flag The synchronization program may then check the validity flag and return the status of the flag to the second program If the validity flag is invalid, the second program may refresh the local cached copy with the primary data set before using the local cached copy In one embodiment, the second program may then set the validity flag for the local cached copy to valid. In another embodiment, the second program may notify the synchronization progτam that the data set copy has been updated, and the synchronization program may then set the associated validity flag to valid. In one embodiment, the computer system may be a single-image cluster which may mclude several servers capable of cooperative parallel processmg of data. External non-volatile memory may be shared by the servers. A program may be copied to and executed simultaneously on one or more servers. A data synchronization program may perform tasks associated with the synchronization of data sets. In one embodiment, a couplmg system configured to manage the synchronization of data may be linked to servers m a cluster. In one embodiment, a couplmg system may reside on a computer system dedicated to the couplmg system task. In another embodiment, the couplmg system may reside as a server on a computer system m the cluster with other servers m the cluster sharing the computer system In some embodiments, a cluster may mclude more than one couplmg system In one embodiment, a synchronization program cooperate with a couplmg system to manage the synchronization of data among programs running on servers m the cluster. A synchronization program may act as an interface to a couplmg system for programs running on a server. In one embodiment, the synchronization program may mclude an application programming interface that mcludes source code level functions that can may be called from the source code of other programs. The functions may allow programs to request the couplmg system and couplmg system interface to perform data synchronization tasks. In one embodiment, a synchronization program may reside on a couplmg system. In another embodiment, one copy of a synchronization program may reside on each server m the cluster connected to a couplmg system. In yet another embodiment, a copy of a synchronization program may be assigned to each program that is running on a server. In one embodiment, a synchronization program may establish and maintain a communications link with a couplmg system. In one embodiment, a validity data structure may exist on each server m the cluster. In another embodiment, a validity data structure may exist on a couplmg interface and may be shared among servers m the cluster. In yet another embodiment, a validity data structure may exist on each computer system m the cluster, and may be shared among servers on a computer system In one embodiment, a couplmg system may mclude a table of mdexes which may be used to keep track of copies of data sets cached on the servers The mdex table may contain information descπbmg the data set copies, information useful for locatmg a data set copy, and information useful for locatmg a validity flag associated with a data set copy In one embodiment, a program running on a server may create a copy of a pπmary data set m local memory. The program may send a message to the synchronization program notifying the synchronization program of the creation of the data set copy The message may mclude information descπbmg the data set copy In one embodiment, the message may mclude a unique identifier or key extracted from records m the data set. The synchronization program may then forward the message to the couplmg facility The couplmg facility may create an entry in an mdex table for the data set copy The entry m the mdex table may mclude information used to locate the validity flag for the data set copy. In some embodiments, a key passed m the message from the first program may be used m the mdex data structure to identify the data set copy The couplmg facility may initialize a validity flag to mdicate that the data set copy is valid The couplmg facility may then send a message to the synchronization program mcludmg information descπbmg the location of the vahdity flag for the data set copy The synchronization program may then forward the message to the program, which may store the vahdity flag location information m memory The process of programs cachmg copies of data sets, requesting synchronization of the copies, and of a couplmg system assigning validity flags to the copies may be repeated as several programs cache copies of pπmary data sets m local memory. At some pomt, a first program may desire to modify a cached copy of the data set. In one embodiment, the first program may directly check the status of a validity flag assigned to the cached copy. In another embodiment, the first program may send a message requesting the status of the validity flag to the synchronization program, which may then read the status of the validity flag and return the status to the first program. If the validity flag mdicates the cached copy is valid, the first program may modify the cached copy directly. The first program may replace the pπmary data set with the cached copy after modifymg the cached copy The first program may then send a message to the synchronization program indicating that the pπmary data set has been modified. The message may mclude information identifying which program made the modification. In one embodiment, the message may mclude a umque identifier or key read from the records m the data set. The synchronization program may forward the message to the couplmg facility. Upon receivmg the message, the couplmg facility may read the entπes m the mdex table and identify the entries for all copies of the data set currently cached by usmg the data descπphon mcluded m the entπes. In some embodiments, a key mcluded m the message may be used to locate entπes m the mdex table by comparing the key to information stored m the entπes. The couplmg facility may then use the locations of the vahdity flags stored with the data descπpnons m the entπes m the mdex table to locate and set the validity flags of cached copies of the data set other than the newly modified copy to mvahd, indicating that the copies are not concurrent with the pπmary data set. In one embodiment, the validity flags may be set to mva d simultaneously. In another embodiment, the validity flags may be set to mvahd seπally. At some pomt after validity flags have been set to mdicate that cached copies of a data set are mvahd, a second program may need to access a cached copy of a data set. The second program may be running on the same server as the first program or on another server m the cluster. The second program may require read only access or it may require wπte access to modify the cached copy. In one embodiment, a program may directly check the status of a validity flag associated with a cached copy. In another embodiment, a program may send a message requesting the status of a validity flag to a synchronization program, which would then read the status of the flag and return the status to the program If the validity flag mdicates that the cached data is mvahd, the second program may replace the cached copy of the data set with the pπmary data set In one embodiment, a program may directly set a vahdity flag for a cached copy to valid In another embodiment, a program may send a message to a synchronization program mdicatmg that a cached copy has been updated, and the synchronization program may set the associated validity flag to valid BRIEF DESCRIPTION OF THE DRAWINGS Figure 1 illustrates a server m which programs share cached data, Figure 2 illustrates a server with programs usmg local copies of a data set and validity flags according to one embodiment, Figure 3 illustrates a server with programs usmg local copies of a data set and a program to manage data synchronization accordmg to one embodiment, Figure 4 is a high-level block diagram of a smgle-system image cluster, Figure 5 illustrates a cluster system without program-level data synchronization, Figure 6 illustrates a cluster system with program-level data synchronization accordmg to one embodiment, Figure 7 is a flowchart illustrating the use of validity flags m data synchronization accordmg to one embodiment, Figure 8 is a flowchart illustrating two programs usmg validity flag to synchronize data accordmg to one embodiment, Figure 9 is a flowchart illustrating creatmg mdexes to copies of data sets duπng the synchronization process accordmg to one embodiment, Figure 10a is a flowchart illustrating a synchronization program managmg the data synchronization process for other programs accordmg to one embodiment, Figure 10b is a continuation of flowchart 10a, Figure 11 is a flowchart illustrating the synchronization process for multiple copies of a data set accordmg to one embodiment, Figure 12a is a flowchart illustrating a couplmg system mterface providmg an interface between a couplmg system and multiple programs to provide data synchronization accordmg to one embodiment, Figure 12b is a continuation of flowchart 12a, Figure 12c is a continuation of flowchart 12b While the mvention is susceptible to vanous modifications and alternative forms, specific embodiments thereof are shown by way of example m the drawmgs and will herem be descπbed m detail It should be understood, however, that the drawmgs and detailed descπption thereto are not mtended to limit the mvention to the particular form disclosed, but on the contrary, the mtention is to cover all modifications, equivalents, and alternatives falling withm the spiπt and scope of the present mvention as defined by the appended claims DETAILED DESCRIPTION OF THE DRAWINGS The term "computer system" as used herem generally descπbes the hardware and software components that m combination allow the execution of computer programs The computer programs may be stored m software, hardware, or a combination or software and hardware A computer system ' s hardware generally mcludes a processor, memory media, and Input Output (I/O) devices As used herein, the term "processor" generally descnbes the logic circuitry that responds to and processes the basic instructions that operate a computer system The term "memory medium" mcludes an installation medium, e.g., a CD-ROM, or floppy disks; a volatile computer system memory such as DRAM, SRAM, EDO RAM, Rambus RAM, etc., or a non-volatile memory such as optical storage or a magnetic medium, e.g., a hard dπve. The memory medium may comprise other types of memory or combinations thereof. In addition, the memory medium may be located in a first computer m which the programs are executed, or may be located m a second computer which connects to the first computer over a network. The term "memory" is used synonymously with "memory medium" herem. A computer system's software generally mcludes at least one operating system, a specialized software program that manages and provides services to other software programs on the computer system. Software may also mclude one or more programs to perform vanous tasks on the computer system and vanous forms of data to be used by the operating system or other programs on the computer system. The data may mclude but are not limited to databases, text files, and graphics files. A computer system's software generally is stored in non- volatile memory or on an installation medium. A program may be copied mto a volatile memory when runnmg on the computer system. Data may be read mto volatile memory as the data is required by a program A computer system may comprise more than one operating system. When there is more than one operating system, resources such as volatile and non-volatile memory, installation media, and processor time may be shared among the operating systems, or specific resources may be exclusively assigned to an operating system. For example, each operating system may be exclusively allocated a region of volatile memory. The region of volatile memory may be referred to as a "partition" or "memory space." A combination of an operating system and assigned or shared resources on a computer system may be referred to as a "server." A computer system thus may mclude one or more servers. Figure 1 - A server m which programs share cached data Figure 1 illustrates a server 10 mcludmg a memory 20 connected to a data storage 30 by a data bus 35. Server 10 may mclude a smgle processor or several processors performing m parallel (processors not shown). A pπmary copy of a database 40 may be stored on the data storage 30. A program 60 and a program 70, runnmg on server 10, may read a data set from database 40 mto memory 20. The data set may be stored m memory 20 as cached data 50. Program 60 and program 70 may share access to cached data 50. If, for example, program 60 modifies cached data 50, then program 70 may immediately see the modification on a subsequent access of cached data 50; there is therefore no need for data synchronization. Figure 2 - A server with programs usmg local copies of a data set and validity flags Figure 2 illustrates one embodiment of a server 10 mcludmg memory 20 connected to data storage 30 by a data bus 35. Server 10 may mclude a smgle processor or several processors performmg m parallel (processors not shown). A list of validity flags 100 may exist on server 10. In one embodiment, validity flags 100 may be provided on another medium, for example on a disk dπve or m hardware registers. A pπmary copy of a database 40 may be stored on data storage 30. A program 60, runnmg on server 10, may read a copy of a pπmary data set from database 40 mto memory 20. The data set may be stored m memory 20 as cached data 80. A validity flag m validity flags 100 may be set to mdicate cached data 80 is valid. A program 70, also runnmg on server 10, may read a copy of the same pπmary data set from database 40 mto memory 20. The data set may be stored m memory 20 as cached data 90 A second validity flag m validity flags 100 may be set to mdicate cached data 90 is valid. Program 60 may then modify cached data 80, and program 60 may replace the pπmary data set m database 40 with cached data 80 Program 60 may then search validity flags 100 for validity flags to other copies of cached data 80. Finding the validity flag for cached data 90, program 60 may set the validity flag to mva d to mdicate cached data 90 is out of synchronization with cached data 80 and database 40. Pπor to accessmg cached data 90, program 70 may check the validity flag m validity flags 100 for cached data 90 Fmdmg the flag to be set to mvahd, program 70 may then synchronize cached data 90 by readmg the pπmary set from database 40 mto cached data 90. Program 70 may then set the flag for cached data 90 in validity flags 100 to valid, mdicatmg that cached data 90 is synchronized Figure 3 - A server with programs usmg local copies of a data set and a program to manage data synchronization Figure 3 illustrates one embodiment of a server 10 mcludmg a memory 20 connected to a data storage 30 by a data bus 35. Server 10 may mclude a smgle processor or several processors performing m parallel (processors not shown) A list of validity flags 100 may exist on server 10. In some embodiments, validity flags 100 may be provided on another medium, for example on a disk dπve or m hardware registers. A pπmary copy of a database 40 may be stored on data storage 30 A data synchronization program 110 may be runnmg on server 10 A program 60 runnmg on server 10 may read a copy of a primary data set from database 40 The data set may be stored m memory 20 as cached data 80 Program 60 may then notify synchronization program 110 of the creation of cached data 80 Program 110 may then set a flag m validity flags 100 to mdicate cached data 80 is valid. A program 70 runnmg on server 10 may read a copy of the same pπmary data set from database 40 as that read by program 60 The data set may be stored m memory 20 as cached data 90. Program 70 may then notify synchronization program 110 of the creation of cached data 90 Synchronization program 110 may then set a validity flag in validity flags 100 to mdicate cached data 90 is vahd. Program 60 may then modify cached data 80 and replace the pπmary copy of the data set m database 40 with cached data 80. Program 60 may then notify synchronization program 110 that cached data 80 has been modified. Synchronization program 110 may then search vahdity flags 100 for flags to other copies of the pπmary data set. Fmdmg the validity flag for cached data 90, program 110 may then set the flag to mva d to mdicate cached data 90 is out of synchronization with cached data 80 and the pπmary data set. In one embodiment, pnor to accessmg cached data 90, program 70 may check the flag m vahdity flags 100 for cached data 90 In another embodiment, program 70 may notify synchronization program 110 that program 70 needs to access cached data 90, and synchronization program 110 may then check the validity flag for cached data 90 m validity flag structure 100 and return the vahdity flag's status to program 70. If the vahdity flag is mvahd, program 70 may then synchronize cached data 90 by readmg the pπmary data set from database 40 mto cached data 90 Program 70 may then notify synchronization program 110 that cached data 90 is synchronized. Synchronization program 110 may then set the validity flag for cached data 90 m validity flags 100 to valid, mdicatmg that cached data 90 is synchronized. Figure 4 - A high-level block diagram of a smgle-system image cluster system Figure 4 illustrates an embodiment of a smgle-system image cluster system that is suitable for implementing the synchronization system and method as descπbed herem. The system may mclude multiple systems (two systems, systems 150 and 160, are shown) runnmg mainframe operating systems such as OS/390 or MVS operating systems; at least one couplmg facility 180 to assist m multisystem data sharmg functions, wherem the couplmg facility 180 is physically connected to systems m the cluster with high-speed couplmg links 185; a timer facility 190 to synchronize time functions among the servers; and various storage and I O devices 320, such as DASD (Direct Access Storage Devices), tape drives, terminals, and printers, connected to the systems by data buses or other physical communication links. Also shown in system 160 is a system partitioned into more than one logical system or server (two servers, servers 191 and 192, are shown on system 160). The single-system image cluster system provides dynamic workload balancing among the servers in the cluster. To a client working at a terminal or to an application program running on the cluster, the servers and other hardware and software in a single-system image cluster system appear as one logical system. Figure 5 - A cluster system without program-level data synchronization In Figure 5, an embodiment of a cluster system is shown without program-level data synchronization. Servers 200 and 210 may be connected to a storage device 220 and to a coupling system 230. A program 250, running on server 200, may read a copy of a primary data set from a database 240 and store the copy in a cached data 255. A program 260, running on server 200, may read a copy of the same primary data set from database 240 and store the copy in a cached data 265. A program 270, running on server 210, may also read a copy of the same primary data set from database 240 and store the copy in a cached data 275. Program 250 may then modify cached data 260 and write cached data 260 to database 240. Program 270 may then access cached data 275. Since coupling system 230 may not provide synchronization for the programs' cached data, cached data 275 may not be concurrent with the latest changes in database 240. It is possible that program 270 may write the non-concuπent cached data 275 to database 240 after program 250 has updated the database, overwriting the changes made by program 250. Figure 6 - A cluster system with program-level data synchronization Figure 6 illustrates one embodiment of a cluster system with program-level data synchronization. A server 300 and a server 310 may be connected to a storage device 320 and to a coupling system 330. In one embodiment, the cluster is a single-system image cluster system, and the coupling system 330 is a Coupling Facility (CF). A database 325 may be stored on a storage device 320. A coupling system interface 340 may be running on server 300 and may establish a link with coupling system 330. The link may be maintained as long as coupling system interface 340 is running. A coupling system interface 345 may be running on server 310 and may establish a link with coupling system 330. The link may be maintained as long as coupling system interface 345 is running. Server 300 may include a list of validity flags 350, and server 310 may include a list of validity flags 355. In one embodiment, the cluster is a single-system image cluster system, and validity flags may be represented by bits in a Hardware Service Area (HSA) which may be located on systems in the cluster. A program 360, running on server 300, may read a copy of a primary data set from database 325 and store the copy in a cached data 365. Program 360 may then send a registration request to coupling system interface 340. The registration request may include a unique identifier or key which identifies cached data 365. Coupling system interface 340 may then forward the registration request to coupling system 330. Receiving the registration request, coupling system 330 may assign a validity flag in validity flags 350 to cached data 365, and may initialize the validity flag to valid. Coupling system 330 may then create an entry for cached data 365 in an index table 335. The entry may include information identifying the program 360 requesting data registration, information identifying the cached data 365 including the key passed in the registration request, and information identifying the location of the validity flag in validity flags 350 assigned to cached data 365 Couplmg system 330 may then send a message mcludmg the identity of the validity flag m validity flags 350 assigned to cached data 365 to couplmg system mterface 340 Couplmg system interface 340 may then forward the message to program 360 Program 360 may store the identity of the validity flag assigned to cached data 365 m program memory A program 370, runnmg on server 300, may read a copy of the same pπmary data set from database 325 and store the copy in a cached data 375 Program 370 may then send a registration request to couplmg system mterface 340 The registration request may mclude a unique identifier or key which identifies cached data 375 Couplmg system mterface 340 may then forward the registration request to couplmg system 330 Couplmg system 330 may then perform the same synchronization tasks for cached data 375 as listed above for cached data 365 A program 380, runnmg on server 310, may also read a copy of the pπmary data set from database 325 and store the copy m a cached data 385 Program 380 may then send a registration request to couplmg system mterface 340 The registration request may mclude a unique identifier or key for cached data 385 Couplmg system mterface 340 may then forward the registration request to couplmg system 330 Receivmg the registration request, couplmg system 330 may assign a validity flag m validity flags 355 to cached data 385, and may initialize the flag to vahd Couplmg system 330 may then create an entry for cached data 385 m an mdex table 335 The entry may mclude information identifying the program 380 requesting data registration, information identifying the cached data 385 mcludmg the key passed m the registration request, and information identifying the location of the validity flag m vahdity flags 355 assigned to cached data 385 Couplmg system 330 may then send a message mcludmg the identity of the validity flag m validity flags 355 assigned to cached data 385 to couplmg system mterface 345 Couplmg system mterface 345 may then forward the message to program 380, which may store the identity of the validity flag assigned to cached data 385 m program memory Program 360 may then modify cached data 365 and update the pπmary data set m database 325 with cached data 365 Program 360 may then send a cross mvahdate message to couplmg system mterface 340 Couplmg system mterface 340 may then forward the cross mvahdate message to couplmg system 330 In one embodiment, a cross mvahdate message may inform a couplmg system that a pπmary data set has been modified, requiring the validity flags for all cached copies of the pπmary data set to be set to mvahd In one embodiment, a cross mvahdate message may contam a key identifying the cached data that was modified and used to update the pπmary data set Receivmg the cross mvahdate message, couplmg system 330 may then search mdex table 335 for entπes associated with copies of the same data set as m cached data 365 In one embodiment, a key passed m a cross mvahdate message may be compared with keys previously passed m registration messages and stored m entπes m an mdex table, with matching keys identifying copies of the same data set Fmdmg entπes m the mdex table 335 for cached data 375 and cached data 385, couplmg system 330 may use the validity flag location information stored m the mdex table entnes to set the validity flags assigned to cached data 375 and cached data 385 to mva d, sigmfymg that cached data 375 and cached data 385 are not concurrent with the pπmary data set In one embodiment, a couplmg system sets the flags to mvahd one at a time or seπally In another embodiment, a couplmg system sets the flags to mvahd simultaneously Program 380 may then require access to cached data 385 In one embodiment, a program may directly check the validity flag assigned to a cached data m a list of validity flags In another embodiment, a program may request the status of a validity flag from a couplmg system mterface, which may then check the validity flag assigned to a cached data m a validity flags list and return to the program the status of the validity flag assigned to the cached data If the status of the flag is valid, program 380 may access cached data 385 directly If the status of the flag is mva d, program 380 may replace cached data 385 with the latest version of the data set from database 325 before accessmg cached data 385 In one embodiment, a program may then sets a validity flag m a list of validity flags associated with a cached data to valid In another embodiment, a program notifies a couplmg system mterface that a cached data has been updated, and the couplmg system mterface sets the validity flag m the validity flags associated with the cached data to "valid " Figure 7 - A flowchart illustrating the use of validity flags m data synchronization In Figure 7, a flowchart is presented to illustrate one embodiment of a method of data synchronization In step 400, a first copy of a pπmary data set is created A first validity flag is assigned to the first copy and initialized to "valid" m step 401 In step 402, a second copy of the pπmary data set is created A second vahdity flag is assigned to the second copy and initialized to valid m step 403 In step 404, the first copy of the data set is modified, and the pπmary copy is replaced with the modified first copy in step 405 In response to the pπmary copy bemg updated, the second flag is set to mva d m step 406 In step 407, the second copy is replaced with the pπmary copy as a result of the validity flag associated with the second copy bemg mvahd In step 408, the second flag is set to valid to mdicate the second copy has been updated Figure 8 - A flowchart illustrating two programs usmg validity flags to synchronize data In Figure 8, a flowchart is presented to illustrate one embodiment of a method where two programs cooperate m data synchronization In step 420, a first program creates a first copy of a pπmary data set The first program sets a first validity flag to valid for the first copy m step 421 In step 422, a second program creates a second copy of a pπmary data set The second program sets a second vahdity flag to valid for the second copy m step 423 In step 424, the first copy of the data set is modified by the first program, and the pπmary copy is replaced with the modified first copy by the first program m step 425 The validity flag associated with the second copy is set to mvahd by the first program m step 426 In step 427, the second program requires a read or wπte access to the second copy Before accessmg the second copy, the second program checks the status of the second validity flag m step 428 If the second flag is valid, the second program proceeds to step 432 and accesses the second copy If the second flag is mvahd, the second program proceeds to step 430 and replaces the second copy with the pπmary copy In step 431, the second flag is set to valid by the second program to mdicate the second copy has been updated, and the second program proceeds to step 432 and accesses the second copy Figure 9 - A flowchart illustrating creating mdexes to copies of data sets durmg the synchronization process In Figure 9, a flowchart is presented to illustrate one embodiment of a method of data synchronization where an mdex is created for the data set copies In step 440, a first copy of a pπmary data set is created A first validity flag is assigned to the first copy and initialized to vahd m step 441 In step 442, a first mdex to the first copy is created and stored m an mdex table The first mdex may mclude a umque identifier, or key, that identifies the first copy The first mdex may also mclude information that may be used to locate the first flag In step 443, a second copy of the pπmary data set is created A second vahdity flag is assigned to the second copy and initialized to valid m step 444 In step 445, a second mdex to the second copy is created and stored m the mdex table The second mdex may mclude a umque identifier, or key, that identifies the second copy The second mdex may also mclude information that may be used to locate the second flag In step 446, the first copy of the data set is modified, and the pπmary copy is replaced with the modified first copy m step 447 In step 448, the mdex table may be searched usmg the first mdex key, the first mdex key may be matched to the second mdex key m the mdex table, and the second flag located with the flag location information m the second mdex The second flag is set to mvahd m step 449 In step 450, the second copy is replaced with the pπmary copy as a result of the vahdity flag associated with the second copy bemg mvahd In step 451, the second flag is set to valid to mdicate the second copy has been updated. Figure 10a and 10b - A flowchart illustrating a synchronization program managmg the data synchronization process for other programs Figures 10a and 10b present a flowchart illustrating one embodiment of a method of data synchronization where a synchronization program manages the synchronization process for other programs In step 460, a first program creates a first copy of a pπmary data set. A first validity flag is assigned to the first copy, and the first program initializes the first flag to vahd m step 461. In step 462, the first program sends a synchronization request to the third program (the synchronization program). In step 463, a first mdex to the first copy is created by the third program and stored m an mdex table. The first mdex may mclude a umque identifier, or key, that identifies the first copy The first mdex may also mclude information that may be used to locate the first flag. In step 464, a second program creates a second copy of the pπmary data set A second validity flag is assigned to the second copy, and the second program initializes the second flag to valid m step 465. In step 466, the second program sends a synchronization request to the third program In step 467, a second mdex to the second copy is created by the third program and stored m an mdex table. The second mdex may mclude a umque identifier, or key, that identifies the second copy. The second mdex may also mclude information that may be used to locate the second flag. In step 468, the first copy of the data set is modified by the first program, and the pπmary copy is replaced with the modified first copy by the first program m step 469. In step 470, the first program notifies the third program that the pπmary copy has been modified. In step 471, the third program sets the second flag to mva d. The second program requires access to the second copy and sends an access request to the third program m step 472. The third program checks the second validity flag m step 473 In step 474, if the second validity flag is valid, the third program proceeds to step 475 and tells the second program to access the second copy. In step 474, if the second vahdity flag is mvahd, the third program proceeds to step 476 and tells the second program the second copy must be updated before accessmg it. In step 476, the second program replaces the second copy with the pπmary copy. In step 477, the second program sets the second flag to vahd to mdicate the second copy has been updated The second program then accesses the second copy m step 478. Figure 11 - A flowchart illustrating the synchronization process for multiple copies of a data set Figure 11 illustrates one embodiment of a method of data synchronization applied to multiple copies of a data set. It is important to note that all of the examples of embodiments descπbed herem may be extended to cover multiple copies as descnbed m this embodiment. N is used to represent a number of copies that may be created. Examples of factors that may limit the number of copies that may be created mclude, but are not limited to, an operating system-imposed limit, an application-imposed limit, a limit on the number of resources such as validity flags and mdex table entπes, or a limit on memory available. In step 480, copies 1-N of a data set are created. Validity flags are initialized to "valid" for copies 1-N m step 481, and mdexes for copies 1-N are created and stored in an mdex table m step 482. In step 483, a copy 1 is modified, and the pπmary copy is replaced with copy 1 m step 484. In step 485, the mdex table is searched for all mdexes that match the mdex of copy 1, and mdexes 2-N are located In step 486, validity flag location information stored m mdexes 2-N is used to set validity flags 2-N to mvahd Figure 12a, 12b, and 12c - A flowchart illustrating a couplmg system mterface between a couplmg system and multiple programs to provide data synchronization In Figures 12a- 12c, a flowchart is used to illustrate one embodiment of a cluster system mcludmg a couplmg system and a couplmg system mterface between the couplmg system and multiple programs runnmg on the cluster's servers In one embodiment, the cluster system may be a smgle-system image cluster system with at least one Cluster Facility (CF) In step 500, a couplmg system mterface, a program runnmg on a first server m the cluster, establishes a link with the couplmg system In one embodiment, the link may be mamtamed by the couplmg system mterface as long as the couplmg system mterface is runnmg and the couplmg system is available In step 501, a first program runnmg on the first server creates a first copy of a primary data set In one embodiment, a data set may be extracted from a database stored on a data storage device shared by the servers m the cluster In one embodiment, a data set may be constructed from multiple sources on a data storage, wherem the data m the data set may not have a one-to-one correspondence to a physical data set m a database Examples of data sets mclude, but are not limited to, a data record, a data group, a data table, a random table, and a row from a table A data record may be defined as a groupmg of one or more data items The data items typically provide information about an object or entity Data items m a record may be referred to as fields m the record A data group may be defined as a collection of logically related data fields that may be stored m contiguous memory A data table may be defined as a type of data set m which data records are stored m rows, a row mcludmg one or more records, and where the table mcludes one or more types of row A random table may be defined as multiple occurrences of a data group accessed by a specific key via a hashmg algoπthm A row may be defined as a row extracted from a data table or random table In step 502, the first program creates an mdex to the first copy In one embodiment, an mdex may be created from a field or fields of a data set The field or fields used to create an mdex may mclude a unique identifier or key that may serve to distinguish the data set from other data sets m the database Examples of types of data sets that may mclude a key used to uniquely identify the data set mclude, but are not limited to, a record, a group, a data table, a random table, and a row In one embodiment, a key is created for data sets when the data sets are initially created m the database In another embodiment, a utility program may be used to modify an existing database by creating a key for data sets m the database In one embodiment, the mdex may also mclude a field containing information that may be used to distinguish between copies of a data set Thus, the mdex may be useful for distinguishing among different data sets, for identifying copies of a particular data set, and for distinguishing among copies of a data set duπng the data synchronization process In step 503, the first program sends a synchronization request, which may be refeπed to as a registration request, to the couplmg system mterface The request may mclude the mdex created by the first program In one embodiment, a request may also mclude information identifying a program as the sender of the request In one embodiment, the request may be sent to the couplmg system mterface, and the couplmg system mterface may processed the request immediately In one embodiment, if a couplmg system mterface is busy at the time a program attempts to send the request, the program may wait for the couplmg system mterface to complete its current operation before sendmg the request In another embodiment, a couplmg system mterface may mclude a message queue, a program may post a request m the message queue, and the couplmg system mterface may process messages posted m the message queue m a pπonty order An example of a pπoπty order that may be used m some embodiments is first-in, first-out (FIFO) processmg. A number of embodiments utilizing other pnoπty ordering schemes will be obvious to one skilled m the art In step 504, the couplmg system mterface forwards the registration request to the couplmg system The couplmg system then processes the registration request In step 505, the couplmg system assigns a first validity flag m a validity structure on the first server to the first copy and initializes the first flag to valid In one embodiment, a validity structure may be a portion of memory where each bit in the portion represents one flag. In another embodiment, a validity structure may be a list of data structures, a data structure may mclude one or more fields, and one or more fields may represent the validity flag In one embodiment, a validity flag may be represented by one bit, 1 (bit set) may mdicate vahd data, and 0 (bit clear) may mdicate mvahd data. In another embodiment, a flag may be represented by one bit, 1 (bit set) may mdicate mva d data, and 0 (bit clear) may mdicate valid data. In another embodiment, a validity flag may mclude more than one bit. In yet another embodiment, a validity flag may be a field m a data structure, and the field may be set to different values to represent valid and mvahd data sets. In one embodiment the system may be a smgle-system image cluster system, and the flag may be a bit m the Hardware Service Area (HSA) In step 506, the couplmg system stores the mdex m an mdex table on the couplmg system In one embodiment, a couplmg system may append mformation that may be used to identify the location of a validity flag to an mdex. In one embodiment, mformation used to identify a validity flag location may mclude an identifier for a server the flag is located on, a memory address of a validity structure on the server, and an identifier for a field m the vahdity structure mcludmg the flag. In another embodiment, the system may be a smgle-system image cluster system, a validity flag may be a bit m the Hardware Service Area (HSA), and a vector may be used to identify the bit m the HSA. In step 507, the couplmg system sends a confirmation message to the couplmg system mterface. In one embodiment, a confirmation message may mclude mformation used to identify a validity flag assigned to a cached copy. In another embodiment, a confirmation message may mclude mformation to identify a program that created a cached copy In yet another embodiment, a confirmation message may mclude mformation to identify a cached copy In one embodiment, a couplmg system mterface may keep a copy of mformation m a confirmation message m local memory, which then may be used to directly access a validity flag associated with a cached copy. In step 508, the couplmg system mterface forwards the message to the first program. In step 509, the first program stores m its local memory mformation from the message that may be used to locate the first validity flag In steps 510-518, the second program follows the same process the first program followed m steps 501- 509. In the following descπption, the second program is descπbed as runnmg on a second server m the cluster, but it is to be understood that the process may be applied to a second process runnmg on the first server. In step 510, the second program creates a second copy of the pπmary data set on the second server. In step 511, the second program creates an mdex to the second copy. The second program sends a registration request mcludmg the mdex to a couplmg system mterface runnmg on the second server m step 512. In step 513, the couplmg system forwards the registration request to the couplmg system. In step 514, the couplmg system assigns and initializes a second validity flag m the validity flag structure located on the second server. In step 515, the couplmg system stores the mdex and the second flag location m the mdex table. The couplmg system then sends a confirmation message to the couplmg system mterface m step 516. The message is forwarded to the second program by the couplmg system mterface m step 517. In step 518, the second program stores the second flag location mformation m local memory. The first program checks the first vahdity flag, finds the flag to be vahd, and modifies the first copy m step 519 The first program updates the database with the modified first copy m step 520 In step 521 , the first program sends a message to the couplmg system mterface mdicatmg that the first copy has been modified The message may be called a "cross invalidation" message In one embodiment, the message may mclude the mdex identifying the first copy The couplmg system mterface forwards the message to the couplmg system m step 522 The couplmg system then processes the cross invalidation message In step 523, the couplmg system uses the mformation m the message to search the mdex table for other copies of the same data set as the first copy, and finds the mdex for the second copy In one embodiment, the mdex passed m the message is used to match with other mdexes m the mdex table A key m the mdex may uniquely identify the data set that has been copied In one embodiment, mformation m the mdex may be used to distmguish among copies of a data set, so that the search skips the mdex to the first copy when the mdex to the first copy m the mdex table exactly matches the mdex to the first copy m the message After locating the mdex to the second copy, the couplmg system sets the second validity flag for the second copy to mvahd m step 524 In one embodiment, the couplmg system may use information stored with the mdex m the mdex table to find the second validity flag At some pomt, the second program may desire to access the second copy of the data set In one embodiment, the second program may send an access request message to the couplmg system mterface m step 525, and the couplmg system mterface may read the second validity flag m step 526 In one embodiment, the second program may send mformation used to locate the second flag m the access request message In another embodiment, the couplmg system mterface may have stored the information identifying the location of the second flag when processmg the confirmation message from the couplmg system, and may use the stored information to read the second flag After readmg the second flag, the couplmg system mterface checks the results of the read m step 527 If the flag is vahd, the couplmg system mterface proceeds directly to step 532 and sends a message to the second program telling it to proceed with the access of the second copy If the flag is mvahd, the couplmg system mterface proceeds to step 528 and sends a message to the second program telling it to update the second copy before proceedmg In step 529, the second program updates the second copy with the pπmary copy from the database, and then sends a message notifying the couplmg system mterface that the second copy has been updated m step 530 The couplmg system mterface sets the second flag to valid m step 531 In step 532, the couplmg system mterface sends a message to the second program telling the second program to proceed with the access of the second copy In one embodiment, steps 530 and 531 may be replaced by the second program directly setting the second flag to valid after updating Finally, m step 533 the second program accesses the second copy Vanous embodiments further mclude receivmg or storing instructions and or data implemented m accordance with the foregomg descπption upon a earner medium Suitable earner media mclude memory media or storage media such as magnetic or optical media, e g , disk or CD-ROM, as well as signals such as electncal, electromagnetic, or digital signals, conveyed via a communication medium such as networks and/or a wireless link Additional Information The basic shared memory model used by the MVS operating system tends to become less efficient as the number of machines (CPU's) sharmg memory mcreases Typically, each machine must take an ENQ on everything it uses whether any other machine is usmg it or not The generally accepted number of processors at which the overall thruput DROPS is around 15 The basic concept behind sysplex is that a processor takes a registered mterest m anything it needs (buffer, record, and so on) This registration of mterest generates a lmear model of use. Sysplex tends to have a 5% overhead but scales well beyond MVS Parallel sysplex is an industry term for a sysplex usmg the extended facilities of a Couplmg Facility to provide data sharmg Normally, the term sysplex and parallel sysplex are used rnterchangeability In one embodiment, a program may use the oπgmal sysplex XCF facilities or may fully exploit the XES facilities of a parallel sysplex Some applications may be heavily dependant on a common parameter file and may utilize an rn-memory (common storage) cache to vastly speed access to these parameters by stagmg frequently used items in memory Use of rn-memory cache m addition to any DBMS or hardware cache may provide access to parameters this side of the DBMS An implementation of a managed cache accordmg to the pnor art was m pπvate storage. As clients moved to multiple processmg regions (IMS MPP's and CICS MRO's), the cache was moved to common storage, for example, storage shared by multiple address spaces. Generally, common memory is not available m a sysplex environment Without a common cache, mtegπty of the cache cannot be provided if any maintenance of items stored m cache is allowed Some application programs have always been able to access application owned areas of common storage (PDG m CSA) These were typically accessed as simple tables. Recent applications have used a geneπc random table facility rather than use a PDG. An API may provide direct access by key, no data group size limit, and the ability to easily use secondary keys These random tables may be stored m common storage. Agam, common memory is not available m a sysplex environment. Without a common cache, mtegπty of random tables cannot be provided as the tables m different machmes would never be m sync. Sysplex may provide no shared memory as well as simultaneous updates to DBMS from multiple MVS images viewed by user as smgle image. An application may provide an rn-memory cache of frequently used items to vastly improve performance. An application may utilize a PDG and random tables housmg application level data for the same reason. With simultaneous updates to a database from multiple MVS images, the cached data could easily become backlevel m relation to the hardened version (DASD or database version) with detrimental impact on transactions runnmg on those multiple MVS images. In summary, a synchronization program may know everything cached by a program m every MVS image and if an item is changed by one image, it tells all the other images to update. These items may be a database item or format dependmg on options selected, a PD Table, PDG, Random Table, or Random Table ROW In one embodiment, substantially every item with sysplex synchronization enabled is registered with the sysplex couplmg facility when read mto the cache. If the item is purged from the cache, the registered mterest is removed. Sysplex may use a technique of Cross Invalidation through HSA (hardware system area). A cross mvahdate request is a simultaneous synchronous notification of all MVS images, with a registered mterest, without any CPU interrupts. A synchronization program checks the vahdity bit (HSA vector) before allowing an application to access an item. If mvahd, the program is instructed to reread from the DBMS or otherwise refresh the item. Each use of a synchronized item is preceded by a test of the validity bit. The macro used for this test has an approximately 30 instruction overhead. Added to this is the increased instruction path to set up the test. In one embodiment, the synchronization program is a cancelable started task runnmg from an authorized library in supervisor mode. It initializes and spends almost all of its life in a wait Other than the inherent cost of runnmg a quiescent address space, its costs should be negligible If specific formats or PCDs are never changed m production, changing their definitions to not require sysplex synchronization reduces the overhead and improves performance. The synchronization program environment may run on a standard sysplex. In one embodiment, any collection of CPUs that can ran a sysplex may be used to support the synchronization. Any significant production use of the MVS Logger on a sysplex may require either a non-volatile couplmg facility (for example, UPS on CPU runnmg the CF) or dual CFs to ensure mtegπty of the logged data withm the CF. Once sysplex is mtended for Production use, most users then plan for a fault tolerant sysplex (mcludmg dual sysplex timers, couplmg facility, and so on). Durmg planning for a sysplex migration, a user should consider the synchronization program as he or she would any sysplex exploiting system. In one embodiment, the synchronization program can run on any available CF, standalone (9674), LPAR'd (9672 or 711 base machine), or under an ICMF (511 or 711 based machmes). HLA (high level ASSEMBLER) is part of OS/390 and is required for the synchronization program, as well as all sysplex exploiting systems. The synchronization program should run on all levels of CF's with no impact. In one embodiment, the synchronization program has a moderate footprint, either m sysplex mode or stand alone. The largest impact may be due to the sysplex requirement that every item to be controlled have a umque ID across all MVS images m the sysplex. In order to provide an absolutely unique ID for every item m a database, as well as all PDGs and random table rows rows, the program may hard assign an ID to every dictionary item. Initially assignment may be made duπng mstallation of the program and, ongomg, by database mamtenance. The ID is reassigned duπng any migration. This may cause a 16 byte overhead per database item. Once active, each item registered with the couplmg facility may be assigned a vector. The combination of 16 byte ID and vector may cause an mcrease of 20 bytes per active item. The synchronization program may utilize two types of CF structures, Cache and List. The synchronization program may use a directory-only cache for all synchronization. Sizing is heavily dependant on the level of tablmg bemg done as well as product mix. The ID assigned to each database item is generated from a one byte connection ID assigned by sysplex to the synchronization program's couplmg facility structure connection (unique withm the sysplex) and the standard STORE CLOCK. The resultant 9 byte ID is completely unique number withm the sysplex. Couplmg Facility REBUILD's may be tπggered by the system due to a CF failure or by operator request. Sysplex may notify every synchronization program that a REBUILD is required. The synchronization program may freeze all transactions withm its processmg regions and participates m the rebuild. As a Directory Only CF Cache can only be reallocated (none of its contents may be copied), the rebuild tends to be a very fast process. Once the new CF is built, transactions processmg resumes. Once started, all transactions attempting to access the CF bemg rebuilt (for example, all of them) issues an ENQ and wait until the CF is rebuilt or the synchronization program releases all enqueues via termination. Once the REBUILD is complete, the structure is empty. This effectively purges all ECS A storage m each MVS image, that is, a complete cache purge! As stated earlier, common storage is generally not available m sysplex. The objectives of a synchronization program supporting and exploiting sysplex facilities may mclude providmg the benefits of common storage cache by synchronization of multiple caches. The nature of access to the facilities provided by XES is that it has numenc restπctions, for example, maximum 32 MVS images m a sysplex, maximum of 256 connections from any one MVS image, and so on Additionally, compared to a normal Couplmg Facility request, the initial connection to a CF Structure has a fairly high overhead The connection is anchored to the system TCB and it is not desirable to use the CICS or IMS TCB for a connection Note also that many of the exits reqmred as part of the XES services must run SRB mode All of this led to the use of a server address space The address space is designed make and own the connections to a CF Structure In one embodiment, the synchronization program 1 Starts and goes non-swappable 2 Obtams a system LX and makes available to the programs a set of routines 3 Makes a connection with the appropπate CF structure 4 WAITs for commands from programs In one embodiment, the synchronization program's design is for an extremely fault tolerant 24 / 7 server with the following properties It may allow automatic restart of any of its sub-tasks that abend up to a site defined limit It may allow all subroutines to be shutdown, reloaded from a library, and restarted It may fully support Couplmg Facility Alter and Rebuild events It may provide for full tracing of all internal and external events It may allow full Dumps on request without interruption of service It may spm all dumps to GDG for use while the synchronization program continues It may mark all Task Work Areas with unique Eye-Catchers It may use Event Queues associated with all WAIT/POST communication among and between tasks to ensure all events are responded to In one embodiment, all items cached m a CF Structure must have a unique 16 byte ID This is required for the CF to track which items have registered mterest To ensure uniqueness, the ID is generated from a Store Clock and the CF Connection Number as well as Format and Company Duπng mstallation, the entire database is converted This mcrease of DASD is 16 bytes per database item Any item added onlme has an ID assigned at creation time The ID is not stored on any database D/R or RCS formatted file, it is therefore recreated on any migration or mstallation The GTF has previously supported Default and Named mdexes for the database cache Internally, a program used the KEY length to determine which mdex to search, located the mdex, and then searched Note that due to mdex sharmg, the size of the mdexes had little to do with any one format In one embodiment, Default and Named mdexes are no longer supported Rather, each format/company usmg tablmg has its own mdex allocated directly off a format definition table This techmque removes an entire layer of computation (key to mdex decision) and search (list of mdexes) In addition, as the size of any one mdex is reduced (only contains one Format Company) the speed of the actual mdex search is mcreased Havmg each Format Company m its own mdex also eases support for Tablmg Options As the lock taken duπng mamtenance is at the mdex level this provides lockmg at a much lower level than the previous Default or Named mdex techmque and reduces lock contention In one embodiment, a synchronization level allows one to reduce or stop synchronization for a specific Format/Company from Item to Format to None This may be used at one's discretion to reduce or remove the overhead of synchronization for those formats that one never maintains m production or those just see no benefit m providmg synchronization Whenever a data group is allocated to a transaction, a program allocates the memory and sets each field to its low collating value (blanks, packed zero, low values, and so on). By default this is done by a program real time for each use of a data group Pnor approaches supported a little-used techmque of storing a data group template, or copy of an empty but initialized DG, m a data space In one embodiment, a template or pre-initialrzed DG is created whenever a data group is germed The template is stored m a new format and tabled withm a Process Dictionary chamed off the Genned DG Definition Whenever a DG is to be allocated to a transaction, storage is obtamed and the template is copied over the storage This may provide noticeable reduction m program overhead, especially m high volume transactions that use numerous data groups The improved logic may replace a loop of 12-18 instructions per field with approximately 8 instructions per data group Permanent Data Groups may be accessed directly by application programs, for example, without a service program. In order to synchronize PDG changes across a sysplex, however, a synchronization program must KNOW when a PDG changes. In one embodiment, a program registers mterest m a PDG on initial allocation. The program validates a PDG on every allocation. If mvahd, for example changed by some other MVS image m the sysplex, a field of the PDG is set to mdicate this The mamtenance program(s) may be mvoked because the PDG is new, the contents are bemg changed, or the PDG is mvahd. Its actions are different m each case. For a new PDG, no additional logic is required Whenever a PDG is changed, the mamtenance program(s) must issue a new activity so the synchronization program notifies all other Images with a registered mterest that their PDG is backlevel. The sysplex term is XI (cross mvahdate). Respondmg to an mvahd PDG, the mamtenance program(s) may rebuild the PDG and then issue the same activity so the synchronization program re-registers this image as havmg a valid PDG. The sysplex term is RR (read and register). In one embodiment, the existing Random Table function is enhanced to support synchronized tables across a sysplex This mcludes modification of the base definition of random tables to mdicate the type of table synchronization and ROW REBUILD activity as well as internal changes m the support modules. In one embodiment, the Random Table definition is modified to provide two new fields and an improved view of the table definition. If a synchronization program is m use, the validity of a table Definition (from the internal Table of Tables mamtamed by the Random Table service program) is checked when first used by a transaction and the definition reloaded from a database if required. Table synchronization may be None, Table, or Row. All tables usmg synchronization have table level synchronization for somce as the table validity is checked before any ROW testing. In one embodiment, all tables usmg ROW synchronization (even those usmg Load On First Access) MUST provide an Estimated Number Of Entπes. In one embodiment, synchronization always requires a umque ID. For Random Table Rows, this ID mcludes the Slot number HASHed from its natural (or alternate) key. Tables used only as work table use NONE as synchronization level TABLE level synchronization causes programs to signal the synchronization program to cross mvahdate all other MVS images when a table is updated or deleted m a MVS image. This option uses the ability of the random table system to respond no table exists and allow applications to rebuild. ROW level synchronization causes programs to signal a synchronization program to cross mvahdate all other registered users whenever a row is modified (ADD, CHG, DEL). This does not guarantee that the random tables are the same, just that any items (rows) m multiple MVS images are the same. The next mstance of a program to see the mvahd mdicator on a row mvokes the ROW REBUILD activity defined for the table. The application-supplied program is passed the row key and must rebuild (ADD) or delete it. The row rebuild activity is mvoked when the slot is cross invalidated by actions from another MVS image All rows attached to the slot (synonyms) are rebuilt, for example, as follows accordmg to one embodiment First, the row is moved mto the pπmary mdex target DG The row is deleted The row rebuild activity is issued. The return code is tested An example Row Rebuild exit program may mclude the following steps The program may receive the row key m its normal data group A rebuild is attempted, and the example may read a PCD If the row data can be rebuilt, a row action of ADD is returned If the data cannot be rebuilt, an action of DELETE is returned In one embodiment, the synchronization program mcludes a server address space used by the program's onlme and batch regions for cache synchronization across a sysplex When any of a synchronization program's sub-tasks abend, the owning task automatically restarts the failed task This can result m a loop condition, if the restarted sub- task repeatedly fails with the ongmal abend. To prevent this situation, a synchronization program keeps a count of the number of abends for each sub-task, when a sub-task exceeds the abend limit, it is no longer automatically restarted. Because a synchronization program runs for extended peπods of time, it is also possible that intermittent abends over a long peπod could exceed the abend limit. This condition is prevented by peπodically resetting the task abend counter to zero. Note In one embodiment, the abend counter is not reset if it has exceeded the abend-limit Once the limit has been reached, it can only be reset usmg a restart or reload commands. In one embodiment, the task work areas are located by scanning extended pπvate m the dump for the eye- catcher string If the task has been restarted, there may be old copies of the task's WA m the dump. A token is part of the eye-catcher string to make it umque to the task, a program locates the coπect WA (that is, the one for the cuπently executing task) because it generates the eye-catcher string usmg the token from a TCB. In one embodiment, event Queues are the synchronization program's method for asynchronous mter-task communications. It is equivalent to a MVS extended ECB with the following advantages: it is not required to be authorized, and logic is not smgle threaded. In one embodiment, each synchronization program's task has one or more event queues associated with it Other tasks (and PC routines) may request that actions be performed by a task be msertmg an event queue element (EQE) to the appropπate event queue. Event Queue Block is a synchronization program's control block descπbmg an event queue. Event Queue Element is a storage cell holdmg data for an mdividual event These are chamed to EQBs. In one embodiment, the synchronization program may either have the same name on each system, or be given a umque name per system. Each MVS image requires a synchronization program for each of the program environments (that is, a set of databases) on that system that participates m data sharmg across the sysplex. At initialization, an exclusive enqueue is issued. This is to prevent multiple instances of a synchronization program mdependently servicing a smgle cache structure. A trace buffer may manage trace table buffers usmg Data-in- Virtual (DFV) services. In one embodiment, trace table buffers are actually DIV wmdows mto a lmear data set. Each time a SWITCH command is received, the offset of the wmdow m the data set is shifted (mcremented) by the length of the trace table buffer. In one embodiment, a couplmg facility connection manager manages the connection to the Couplmg Facility (CF) cache structure, responds to CF connection exit events, and handles structure rebuilds. When a couplmg facility connection manager connects to the CF structure (either duπng initialization or after bemg restarted), it starts off with no registered mterest to any items therefore anything tabled m the CSA is mvahd so a program's CSA is always invalidated upon connecting to the CF structure In one embodiment, there is a command to manually connect to, or disconnect from, the Couplmg Facility cache stracture. When a synchronization program has been manually disconnected, it does not attempt to automatically reconnect as it would if it were disconnected due to a failure A manual connect request can be used to force a synchronization program to attempt a connection if it failed to detect an event mdicatmg connection is possible, or to reconnect after a manual disconnect. A CONNECT command issued when a synchronization program is already connected forces any transactions on the suspended transaction queue to be resumed (that is posted). In one embodiment, the access logic before normal read-only access of a PDG mcludes Vahd? If so, continue with processmg, use of data or UPDATE as required. Bemg updated by another task? If so, return a SYSTEM BUSY, TRY LATER type message and exit. Invalid? If so, mvoke the initialization routine. One of the update type programs is an application program updating a PDG duπng normal busmess logic. In one embodiment, it is recommended that each and every one of these add the following lmes to the program to inform a program (and therefore a synchronization program) that the PDG has changed. In one embodiment, no other changes may be required to update logic.

Claims: WHAT IS CLAIMED IS: 1 A method compnsmg readmg a first copy of a pπmary data set m a pπmary memory location, storing the first copy m a first memory location, setting a first validity flag to mdicate that the first copy is valid, readmg a second copy of the pπmary data set m the primary memory location, storing the second copy m a second memory location, setting a second validity flag to mdicate that the second copy is valid, modifymg the first copy; and setting the second validity flag to mdicate that the second copy is mvahd after modifymg the first copy 2 The method of claim 1, further compnsmg replacmg the pπmary data set with the modified first copy after the modifymg of the first copy and before the setting of the second vahdity flag to mdicate that the second copy is mvahd, replacmg the second copy with the primary data set after the setting of the second validity flag to mdicate that the second copy is invalid; and setting the second validity flag to mdicate that the second copy is valid after replacmg the second copy with the pπmary data set 3. The method of claim 2, wherem a first program is associated with the first copy, and a second program is associated with the second copy. 4. The method of claim 1, wherem replacmg the second copy with the pπmary data set further compπses- readmg the second validity flag m response to a program requesting access to the second copy, and replacmg the second copy with the pπmary data set before granting the access request if the second validity flag mdicates that the second copy is mvahd. 5. The method of claim 2, further compnsmg: creating a first mdex coπespondmg to the first copy, wherem the first mdex is stored m a fourth memory location, wherem the first mdex is created after readmg the first copy from the pπmary data set; and creating a second mdex correspondmg to the second copy, wherem the second mdex is stored in the fourth memory location, wherem the second mdex is created after readmg the second copy from the pπmary data set. 6 The method of claim 5, further compnsmg: locating the second validity flag by usmg the second mdex before setting the second validity flag to mdicate that the second copy is invalid 7 The method of claim 6, wherem an mdex compπses. a first field compnsmg a descnption of a copy of the data for which the mdex was created, and a second field compnsmg a memory location for a validity flag for the copy of the data set for which the mdex was created. 8 The method of claim 7, further compnsmg- matching the first mdex and the second mdex by comparing the first field of the first mdex and the first field of the second mdex; and wherem locating the second validity flag further compnses locatmg the second validity flag by referencmg contents of the second field of the second mdex 9 The method of claim 8, further compnsmg- readmg and storing a plurality of copies of the pπmary data set at respective memory locations, setting a validity flag to mdicate the copy is valid m response to readmg and storing the copy; and creating an mdex to the copy m the fourth memory location m response to readmg and storing the copy 10. The method of claim 9, further compnsmg setting the validity flag of every copy other than the first copy to mvahd after modifymg the first copy 11 The method of claim 8, wherem a first program is associated with the first copy and a second program is associated with the second copy 12. The method of claim 11 , further compnsmg: the first program requestmg that a third program synchronize the first copy with other copies of the primary data set; the third program creating the first mdex coπespondrng to the first copy m the fourth memory location m response to the first program requesting that the third program synchronize the first copy with other copies of the pπmary data set; the second program requesting that the third program synchronize the second copy with other copies of the pπmary data set; and the third program creating the second mdex coπespondrng to the second copy m the fourth memory location m response to the second program requesting that the third program synchronize the second copy with other copies of the primary data set. 13 The method of claim 11, further compnsmg: the first program modifymg the first copy, the first program replacmg the primary data set with the first copy; the first program notifying a third program that the pπmary data set has been modified; and the tlπrd program setting the second validity flag to mdicate that the second copy is mvahd m response to the first program notifying the tmrd program that the primary data set has been modified, wherem the third program is configured to manage the synchronization of copies of data sets. 14 The method of claim 13, further compnsmg- the second program notifying the third program that the second program desires to access the second copy; the third program readmg the second validity flag, the third program notifying the second program that the second copy is mvahd when the second validity flag is mvahd; the second program readmg the pπmary data set and replacmg the second copy with the primary data set; the third program setting the second validity flag to mdicate that the second copy is valid; and the second program accessmg the second copy when the second validity flag is valid. 15. The method of claim 13 , further compnsmg : the second program readmg the second vahdity flag; the second program reading the primary data set and replacmg the second copy with the pπmary data set when the second validity flag is mvahd; and the second program setting the second vahdity flag to valid. 16 The method of claim 11, wherem the first program and the second program are executable on a computer system, wherem the computer system is a cluster, and wherem the cluster compπses: a plurality of computers, wherem a computer compπses a local memory and at least one validity flag, and wherem a copy of a data set that is stored m the local memory is assigned at least one coπespondrng vahdity flag; a couplmg system compnsmg a local memory, wherem the couplmg system is connected to each of the computeis m the cluster, and wherem the couplmg system is configured to coordmate data sharmg of the cluster; and an external data storage shared by the computers m the cluster. 17. The method of claim 16, wherem each computer further compπses a couplmg system mterface program configured to communicate between the couplmg system and a plurality of programs running on the computei. 18. The method of claim 17, wherem the couplmg system mterface program establishes and maintains a communications link to the couplmg system. 19 The method of claim 17, wherem the local memory of a first computer m the cluster compnses the first memory location, the local memory of a second computer m the cluster compnses the second memory location, the external data storage compnses the primary memory location, and the local memory of the couplmg system compπses the fourth memory location 20. The method of claim 19, further compnsmg creatmg a copy of the primary data set in the local memory of a plurality of computers m the cluster, wherem the creation of the copy compπses. creating an mdex coπespondmg to the copy of the pπmary data set m the local memory of the couplmg system; assigning a validity flag to the copy of the pπmary data set; and setting the validity flag to mdicate that the copy of the primary data set is valid. 21. The method of claim 20, further compnsmg- setting the validity flag of every copy other than the first copy is set to mvahd after modifymg the first copy. 22. The method of claim 19, wherem the first computer further compnses a first program associated with the first copy, and the second computer further compnses a second program associated with the second copy. 23. The method of claim 22, further compnsmg: the first program readmg the first copy of the primary data set from the pπmary data set m the pπmary memory location; the first program storing the first copy m the first memory location; the first program creating the first mdex to the first copy; the first program sendmg a request to synchronize the first copy with other copies of the primary data set to the couplmg system mterface, the request compnsmg sendmg the first mdex to a third program; the couplmg system mterface program forwarding the request to synchronize the first copy to the couplmg system; the couplmg system storing the first mdex to the first copy m the fourth memory location m response to the request; the couplmg system sendmg a first token to the couplmg system mterface, the first token compnsmg a location for the vahdity flag to be used for the first copy; the couplmg system mterface program sendmg the first token to the first program; the first program storing the first token m the first memory; the second program readmg the second copy of the primary data set from the pπmary data set m the pπmary memory location; the second program storing the second copy m the second memory location; the second program creatmg the second mdex to the second copy; the second program sendmg a request to synchronize the second copy with other copies of the primary data set to the couplmg system mterface, the request compnsmg sendmg the second mdex to the third program, the couplmg system mterface program forwarding the request to synchronize the second copy to the couplmg system, the couplmg system storing the second mdex to the second copy in the fourth memory location m response to the request, the couplmg system sendmg a second token to the couplmg system mterface, the second token compnsmg a location for the validity flag to be used for the second copy, the couplmg system mterface program sendmg the second token to the second program, and the second program storing the second token m the second memory 24 The method of claim 22, further compnsmg the first program modifymg the first copy, the first program replacmg the pπmary data set with the first copy, the first program notifymg the couplmg system mterface program that the primary data set has been modified, the couplmg system mterface program notifymg the couplmg system that the primary data set has been modified; and the couplmg system setting the second validity flag to mdicate that the second copy is mvahd in response to the first program notifymg the couplmg system mterface program that the pπmary data set has been modified 25 The method of claim 22, further compnsmg the second program readmg the second vahdity flag, the second program replacmg the second copy with the pπmary data set when the second validity flag is mvahd, and the second program setting the second validity flag to valid 26 The method of claim 21, further compnsmg the second program notifymg the couplmg system mterface program that the second program desires to access the second copy, the couplmg system mterface program readmg the second validity flag, the couplmg system mterface program notifymg the second program that the second copy is mvahd when the second validity flag is mvahd, the second program replacmg the second copy with the pπmary data set, the couplmg system mterface program setting the second validity flag to mdicate that the second copy is valid, and the second program accessmg the second copy when the second validity flag is vahd 27 The method of claim 18, wherem the couplmg system mterface program compnses a plurahty of functions and an application programming mterface, wherein each function is configured to perform at least one data synchronization task, and wherem the application programming mterface is compnsed of a plurality of function calls configured to provide external access to the functions, and wherem the function calls are accessible to a plurality of application programs 28 The method of claim 1, wherem the primary data set is a data record 29 The method of claim 1 , wherem the pπmary data set is a data group. 30 The method of claim 1, wherem the pπmary data set is a data table 31 A system compnsmg a plurality of computers compnsmg a cluster, wherem a computer compnses a local memory and at least one validity flag, and wherem a copy of a data set that is stored m the local memory is assigned at least one coπespondmg validity flag, a couplmg system compnsmg a local memory, wherem the couplmg system is connected to each of the computers m the cluster, and wherem the couplmg system is configured to coordmate data sharmg of the cluster; and an external data storage shared by the computers m the cluster; wherem the local memones of the computers or the couplmg system store program instructions, wherem the program instructions are executable by the computers or the couplmg system to. read a first copy of a pπmary data set m a primary memory location, store the first copy m a first memory location; set a first validity flag to mdicate that the first copy is valid; read a second copy of the pπmary data set m the pπmary memory location; store the second copy m a second memory location, set a second validity flag to mdicate that the second copy is vahd; modify the first copy; and set the second validity flag to mdicate that the second copy is mvahd after modifymg the first copy. 32 The system of claim 31, wherem the program instructions are further executable to. replace the primary data set with the modified first copy after the modifymg of the first copy and before the setting of the second validity flag to mdicate that the second copy is mvahd; replace the second copy with the pπmary data set after the setting of the second validity flag to mdicate that the second copy is mvahd; and set the second validity flag to mdicate that the second copy is valid after replacmg the second copy with the primary data set. 33 The system of claim 32, wherem the program instructions further compπse a first program associated with the first copy and a second program associated with the second copy. 34. The system of claim 32, wherem m replacmg the second copy with the primary data set, the program instructions are further executable to: read the second validity flag m response to a program requesting access to the second copy; and replace the second copy with the pπmary data set before granting the access request if the second validity flag mdicates that the second copy is mva d. 35. The system of claim 32, wherem the program instructions are further executable to: create a first mdex coπespondmg to the first copy, wherem the first mdex is stored m a fourth memory location, wherem the first mdex is created after readmg the first copy from the primary data set; and create a second mdex coπespondmg to the second copy, wherem the second mdex is stored m the fourth memory location, wherem the second mdex is created after readmg the second copy from the pπmary data set. 36 The system of claim 35, wherem the program instructions are further executable to: locate the second validity flag by usmg the second mdex before setting the second validity flag to mdicate that the second copy is mvahd. 37. The system of claim 36, wherem an mdex compnses: a first field compnsmg a descπption of a copy of the data the mdex was created for; and a second field compnsmg a memory location for a validity flag for the copy of the data set the mdex was created for. 38 The system of claim 37, wherem m locating the second validity flag, the program instructions are further executable to- match the first mdex and the second mdex by comparing the first field of the first mdex and the first field of the second mdex; and locate the second validity flag by referencmg contents of the second field of the second mdex. 39 The system of claim 38, wherem the program instructions are further executable to: read and store a plurality of copies of the pπmary data set at respective memory locations; set a validity flag to mdicate the copy is valid m response to readmg and storing the copy; and create an mdex to the copy m the fourth memory location m response to readmg and storing the copy. 40. The system of claim 39, wherem the program instructions are further executable to: set the vahdity flag of every copy other than the first copy to mvalid after modifymg the first copy. 41. The system of claim 37, wherein the program instructions further comprise a first program associated with the first copy and a second program associated with the second copy. 42. The system of claim 41, wherein the program instructions further comprise a third program, wherein the third program is configured to manage the synchronization of copies of data sets being used by the first and second programs. 43. The system of claim 42, wherein the first program is executable to request that the third program synchronize the first copy with other copies of the data set; wherein the third program is executable to create the first index coπesponding to the first copy in the fourth memory location in response to the first program requesting that the third program synchronize the first copy with other copies of the data set; wherein the second program is executable to request that the third program synchronize the second copy with other copies of the primary data set; and wherein the third program is executable to create the second index coπesponding to the second copy in the fourth memory location in response to the second program requesting that the third program synchronize the second copy with other copies of the data set. 44. The system of claim 42, wherein the first program is executable to: modify the first copy; replace the primary data set with the first copy; notify the third program that the primary data set has been modified; and wherein the third program is executable to set the second validity flag to indicate that the second copy is invalid in response to the first program notifying the third program that the primary data set has been modified. 45. The system of claim 44, wherein the second program is executable to notify the third program that the second program desires to access the second copy; wherein the third program is executable to: read the second validity flag; and notify the second program that the second copy is invalid when the second validity flag is invalid; wherein the second program is executable to replace the second copy with the primary data set; wherein the third program is executable to set the second validity flag to indicate that the second copy is valid; and wherein the second program is executable to access the second copy when the second validity flag is valid. 46 The system of claim 44, wherem the second program is executable to read the second validity flag, replace the second copy with the pπmary data set when the second validity flag is mva d; and set the second validity flag to vahd 47 The system of claim 31, wherem each computer further stores a couplmg system mterface program which is executable to communicate between the couplmg system and a plurality of programs running on the computer 48 The system of claim 47, wherem the couplmg system mterface program is executable to establish and mamtam a communications link to the couplmg system. 49 The system of claim 47, wherem the local memory of a first computer m the cluster compnses the first memory location, the local memory of a second computer m the cluster compnses the second memory location, the external data storage compnses the primary memory location, and the local memory of the couplmg system compπses the fourth memory location. 50 The system of claim 49, wherem the program instructions are further executable to create a copy of the pπmary data set m the local memory of a plurahty of computers m the cluster, wherem m creating the copy, the program instructions are further executable to: create an mdex coπespondmg to the copy of the primary data set m the local memory of the couplmg system; assign a validity flag to the copy of the primary data set; and set the validity flag to mdicate that the copy of the pπmary data set is valid 51 The system of claim 50, wherem the program instructions are further executable to set the validity flag of every copy other than the first copy to mvahd after modifymg the first copy 52. The system of claim 50, wherem the first computer further mcludes a first program associated with the first copy, and the second computer further mcludes a second program associated with the second copy 53 The system of claim 52, wherem the first program is executable to. read the first copy of the data set from the pπmary data set m the primary memory location, store the first copy m the first memory location; create the first mdex to the first copy; and send a request to synchronize the first copy with other copies of the data set to the couplmg system mterface, wherem the first program is executable to send the first mdex to a third program, wherem the couplmg system mterface program is executable to forward the request to synchronize the first copy to the couplmg system; wherem the couplmg system is executable to store the first mdex to the first copy m the fourth memory location m response to the request; and send a first token to the couplmg system mterface, the first token compnsmg a location for the validity flag to be used for the first copy; wherem the couplmg system mterface program is executable to send the first token to the first program; wherem the first program is executable to store the first token m the first memory; wherem the second program is executable to: read the second copy of the pπmary data set from the pπmary data set m the pπmary memory location, store the second copy m the second memory location; create the second mdex to the second copy; and send a request to synchronize the second copy with other copies of the primary data set to the couplmg system mterface, wherem the second program is executable to send the second mdex to the third program; wherem the couplmg system mterface program is executable to forward the request to synchronize the second copy to the couplmg system; wherem the couplmg system is executable to: store the second mdex to the second copy m the fourth memory location m response to the request; and send a second token to the couplmg system mterface, the second token compnsmg a location for the validity flag to be used for the second copy; wherem the couplmg system mterface program is executable to send the second token to the second program; and wherem the second program is executable to store the second token m the second memory. 54. The system of claim 52, wherem the first program is executable to: modify the first copy; replace the pπmary data set with the first copy; and notify the couplmg system mterface program that the pπmary data set has been modified; wherem the couplmg system mterface program is executable to notify the couplmg system that the pπmary data set has been modified; and wherem the couplmg system is executable to set the second validity flag to mdicate that the second copy is mvahd m response to the first program notifymg the couplmg system mterface program that the pπmary data set has been modified 55 The system of claim 52, wherem the second program is executable to read the second validity flag, replace the second copy with the pπmary data set when the second validity flag is mvahd, and set the second validity flag to valid 56 The system of claim 51 , wherem the second program is executable to notify the couplmg system mterface program that the second program desires to access the second copy, wherem the couplmg system mterface program is executable to read the second validity flag, and notify the second program that the second copy is mvahd when the second validity flag is mvahd, wherem the second program is executable to replace the second copy with the pπmary data set, wherem the couplmg system mterface program is executable to set the second vahdity flag to mdicate that the second copy is valid, and wherem the second program is executable to access the second copy when the second vahdity flag is valid 57 The system of claim 48, wherem the couplmg system mterface program compπses a plurality of functions and an application programming mterface, wherem each function is configured to perform at least one data synchronization task, and wherem the application programming mterface is compnsed of a plurality of function calls configured to provide external access to the functions, and wherem the function calls are accessible to a plurality of programs 58 The system of claim 31, wherem the pπmary data set is a data record 59 The system of claim 31, wherem the pπmary data set is a data group 60 The system of claim 31 , wherem the pπmary data set is a data table 61 A earner medium compnsmg program instructions, wherem the program instructions are executable by a machine to implement readmg a first copy of a primary data set m a pπmary memory location, storing the first copy m a first memory location, setting a first validity flag to mdicate that the first copy is vahd, readmg a second copy of the pπmary data set m the primary memory location, storing the second copy m a second memory location, setting a second validity flag to mdicate that the second copy is valid, modifymg the first copy; and setting the second validity flag to mdicate that the second copy is mvahd after modifymg the first copy 62 The earner medium of claim 61, wherem the program instructions are further executable by the machme to implement replacmg the primary data set with the modified first copy after the modifymg of the first copy and before the setting of the second validity flag to mdicate that the second copy is mvahd; replacmg the second copy with the pπmary data set after the setting of the second vahdity flag to mdicate that the second copy is mvahd; and setting the second validity flag to mdicate that the second copy is valid after replacmg the second copy with the pπmary data set 63 The earner medium of claim 62, wherem a first program is associated with the first copy, and a second program is associated with the second copy. 64. The earner medium of claim 61, wherem the program instructions are further executable by the machme to implement: readmg the second validity flag m response to a program requesting access to the second copy; and replacmg the second copy with the primary data set before granting the access request if the second vahdity flag mdicates that the second copy is mvahd. 65 The earner medium of claim 62, wherem the program instructions are further executable by the machme to implement: creating a first mdex coπespondmg to the first copy, wherem the first mdex is stored m a fourth memory location, wherem the first mdex is created after readmg the first copy from the primary data set; and creating a second mdex coπespondmg to the second copy, wherem the second mdex is stored m the fourth memory location, wherem the second mdex is created after readmg the second copy from the pπmary data set. 66. The earner medium of claim 65, wherem the program instructions are further executable by the machme to implement locating the second validity flag by usmg the second mdex before setting the second validity flag to mdicate that the second copy is mvahd. 67 The earner medium of claim 66, wherem an mdex compnses: a first field compnsmg a descπption of a copy of the data for which the mdex was created; and a second field compnsmg a memory location for a validity flag for the copy of the data set for which the mdex was created. 68. The earner medium of claim 67, wherem the program instructions are further executable by the machine to implement matching the first mdex and the second mdex by comparing the first field of the first mdex and the first field of the second mdex; and locating the second validity flag by referencmg contents of the second field of the second mdex 69 The earner medium of claim 68, wherem the program mstractions are further executable to implement: readmg and storing a plurahty of copies of the pπmary data set at respective memory locations, wherem m creating a copy of the pπmary data set, the program mstractions are further executable by the machme to implement setting a vahdity flag to mdicate the copy is valid m response to readmg and storing the copy; and creating an mdex to the copy m the fourth memory location m response to readmg and storing the copy 70 The earner medium of claim 69, wherem the program mstractions are further executable by the machme to implement. setting the validity flag of every copy other than the first copy to mvahd after modifymg the first copy. 71. The earner medium of claim 68, wherem a first program is associated with the first copy and a second program is associated with the second copy 72. The earner medium of claim 71, wherem the program mstractions are further executable by a machme to implement: the first program requesting that a third program synchronize the first copy with other copies of the data set; the third program creating the first mdex coπespondmg to the first copy m the fourth memory location m response to the first program requesting that the third program synchronize the first copy with other copies of the data set; the second program requesting that the third program synchronize the second copy with other copies of the data set; and the third program creating the second mdex coπespondmg to the second copy m the fourth memory location m response to the second program requesting that the third program synchronize the second copy with other copies of the data set. 73 The earner medium of claim 71 , wherem the program mstractions are further executable by the machme to implement the first program modifymg the first copy; the first program replacmg the pπmary data set with the first copy; the first program notifymg a third program that the pπmary data set has been modified, and the third program setting the second validity flag to mdicate that the second copy is mvahd m response to the first program notifymg the third program that the pπmary data set has been modified, wherem the third program is configured to manage the synchronization of copies of data sets 74 The earner medium of claim 73, wherem the program mstractions are further executable by the machme to implement. the second program notifymg the third program that the second program desires to access the second copy; the third program readmg the second validity flag; the third program notifymg the second program that the second copy is mvahd when the second validity flag is mvahd; the second program readmg the pπmary data set and replacmg the second copy with the primary data set; the third program setting the second validity flag to mdicate that the second copy is valid; and the second program accessmg the second copy when the second vahdity flag is valid. 75. The earner medium of claim 73, wherem the program instructions are further executable by the machme to implement: the second program readmg the second validity flag, the second program readmg the pπmary data set and replacmg the second copy with the pπmary data set when the second validity flag is mvahd; and the second program setting the second vahdity flag to valid. 76. The earner medium of claim 61, wherem the program mstractions further compnse a plurality of functions and an application programmmg mterface, wherem each function is configured to perform at least one data synchronization task, and wherem the application programmmg mterface is compnsed of a plurahty of function calls configured to provide external access to the functions, and wherem the function calls are accessible to a plurality of application programs. 77. The earner medium of claim 61 , wherem the pπmary data set is a data record. 78. The earner medium of claim 61 , wherem the pπmary data set is a data group. 79. The earner medium of claim 61 , wherem the primary data set is a data table. 80. The earner medium of claim 61 , wherem the earner medium is a memory medium. 81 The method of claim 1 , wherem the primary data set relates to financial transaction data 82 The system of claim 31 , wherem the pπmary data set relates to financial transaction data 83 The earner medium of claim 61 , wherem the pπmary data set relates to financial transaction data 84 A method compnsmg setting a first validity flag to mdicate that a first copy of a pπmary data set is vahd, setting a second vahdity flag to mdicate that a second copy of the pπmary data set is valid, modifymg the first copy, and setting the second vahdity flag to mdicate that the second copy is mvahd after modifymg the first copy 85 A system compnsmg a plurality of computers compnsmg a cluster, wherem a computer compπses a local memory and at least one validity flag, and wherem a copy of a data set that is stored m the local memory is assigned at least one coπespondmg validity flag, a couplmg system compnsmg a local memory, wherem the couplmg system is connected to each of the computers m the cluster, and wherem the local memones of the computers or the couplmg system store program mstractions, wherem the program instructions are executable by the computers or the couplmg system to set a first validity flag to mdicate that a first copy of a primary data set is vahd, set a second validity flag to mdicate that a second copy of the pπmary data set is valid, modify the first copy; and set the second validity flag to mdicate that the second copy is mvahd after modifymg the first copy 86 A earner medium compnsmg program mstractions, wherem the program mstractions are executable by a machme to implement setting a first validity flag to mdicate that a first copy of a pπmary data set is valid, setting a second validity flag to mdicate that a second copy of the pπmary data set is valid, modifymg the first copy; and setting the second validity flag to mdicate that the second copy is mvahd after modifymg the first copy

Inventors: BARTLETT JAMES, KERULIS JOHN, NGAN ROBERT, RASMUSSEN JAY, RITTENHOUSE BRIAN, BARTLETT, JAMES, KERULIS, JOHN, NGAN, ROBERT, RASMUSSEN, JAY, RITTENHOUSE, BRIAN
Applicants: SCIENCES CORP COMP, COMPUTER SCIENCES CORPORATION
Application year: 2000
Main classification: G06F11
IPC codes: G06F17