Abstract:
A method for synchronizing data sharing across multiple interpreted code engines is described comprising: comparing a database timestamp with a first cache timestamp responsive to an attempt to access said first cache; disallowing access to said first cache if said database timestamp is not equal to said first cache timestamp; reloading said first cache with data from said database; and setting said first cache timestamp to equal said database timestamp.

Description:
BACKGROUND  
         [0001]    1. Field of the Invention  
           [0002]    This invention relates generally to the field of computer programming. More particularly, the invention relates to a system and method for synchronizing data sharing across multiple interpreted code engines (e.g., Java virtual machines) and/or applications.  
           [0003]    2. Description of the Related Art  
           [0004]    Java is an object-oriented programming language used to create computer programs which are platform-independent. That is, the same Java object code may be used on numerous different operating systems including Windows 95, Unix, Solaris, and Macintosh; and processors such as Intel® Pentium®-class processors, MIPS processors and AMD Athlon® processors, to name a few. This interoperability makes Java an ideal choice for programming Internet applications.  
           [0005]    Once a program is written in Java source code, the Java compiler generates object code in the form of a Java application or applet. Technically, an “applet” is an application configured specifically to run within a Web browser such as Internet Explorer® or Netscape Navigator® (e.g., embedded in-line as objects within Hypertext Markup Language (“HTML”) documents). As illustrated in FIG. 1, Java applets and applications  100  are executed by a runtime interpreter residing on the client computer  130  commonly referred to as a Java “virtual machine”  110 . The Java virtual machine  110  interprets the platform-independent program code from the application or applet  100  into code which the native client microprocessor  120  can execute (e.g., x 86  instructions in the case of a Pentium®-class processor).  
           [0006]    More than one virtual machine and/or Java application/applet may be concurrently executed on a client. One limitation of prior systems, however, is that no built in mechanism exists for sharing data between two or more virtual machines and/or Java applications. Accordingly, what is needed is a system and method for sharing data between multiple virtual machines and/or applications. What is also needed is a system and method for caching data and maintaining data coherency when data is shared between virtual machines and/or applications.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0007]    A better understanding of the present invention can be obtained from the following detailed description in conjunction with the following drawings, in which:  
         [0008]    [0008]FIG. 1 illustrates a prior art Java virtual machine for interpreting code during runtime.  
         [0009]    [0009]FIG. 2 illustrates one embodiment of a caching system implemented within a Java virtual machine.  
         [0010]    [0010]FIG. 3 illustrates two virtual machines caching data from the same database.  
         [0011]    [0011]FIG. 4 illustrates one embodiment of the invention for maintaining cache coherency using timestamps.  
         [0012]    [0012]FIG. 5 illustrates a method implemented in accordance with one embodiment of the invention.  
         [0013]    [0013]FIG. 6 illustrates cache synchronization using timestamps according to one embodiment of the invention.  
         [0014]    [0014]FIG. 7 illustrates cache synchronization using timestamps according to one embodiment of the invention.  
         [0015]    [0015]FIG. 8 illustrates an exemplary computer system on which embodiments of the invention may be implemented.  
     
    
     DETAILED DESCRIPTION  
       [0016]    In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art that the invention may be practiced without some of these specific details. In other instances, well-known structures and devices are shown in block diagram form to avoid obscuring the underlying principles of the invention.  
         [0017]    As illustrated in FIG. 2, one embodiment of the invention is comprised of a data interface module, referred to herein as a data abstraction layer or “DAL”  210 , which allows the Java virtual machine  130  to communicate with and store data (e.g., object-oriented data) within a relational database  240 . For example, the DAL  210  may include routines (e.g., method calls) which are invoked by the virtual machine  130  to store data, run database queries and retrieve data from the database  240 . Moreover, as described in greater detail below, other virtual machines and applications may concurrently access the database  240  via the data abstraction layer  240  (see FIGS.  3 - 4  and  6 - 7 ).  
         [0018]    In one embodiment, the data abstraction layer  210  includes a cache  200  to store data, thereby providing applications/applets  100  with faster access to the data and reducing strain on the database  240  (e.g., by reducing the number of database reads/writes). In one embodiment, the cache  200  stores the most frequently requested data. However, various other caching techniques and/or algorithms may be employed while still complying with the underlying principles of the invention (e.g., a least-recently used cache replacement policy may be implemented for replacing the contents of the cache). Moreover, variables such as the size of the requested data and whether the data is marked as non-cacheable may also be factored into the caching determination.  
         [0019]    Moreover, various types of data may be stored in the cache  200 . For example, in one embodiment, the cache  200  is used to store metadata which describes the database&#39;s  240 &#39;s structure, attributes, processing or database changes (e.g., the metadata may comprise an index of data stored in the database). It should be noted, however, that various other types of database data may be stored in the cache  200  consistent with the underlying principles of the invention.  
         [0020]    As mentioned briefly above, in one embodiment illustrated in FIG. 3, two or more virtual machines  130 ,  330  and/or Java applications  100 ,  101  may concurrently access the database  140 . Java virtual machines  130 ,  330  typically separate each application&#39;s memory space from all other applications. Accordingly, when two applications  100 ,  101  use the data abstraction layer  210 ,  310  as illustrated in FIG. 3, two separate and distinct instances of the cache  200 ,  300  may concurrently store and modify the same data. As a result, it is necessary to take steps to ensure that the data stored in the caches  200 ,  300  remains synchronized.  
         [0021]    In order to do so, in one embodiment of the invention, illustrated in FIG. 4, a “current timestamp” variable is updated in the caches  200 ,  300 , indicating when the data was loaded into each cache or when the data was last modified. In addition, a current timestamp variable is associated with the database  140 , indicating the time that data in either of the caches  200 ,  300  was modified. In operation, if an application  100  modifies its cache  200  it also modifies the database  140  data and updates the timestamp in the database  140  to indicate that the data was modified. When another application  101  invokes its own cache  300  (e.g., calls a method of the cache  300  object), it performs a lookup of the database  140  timestamp and compares its own timestamp with the database  140  timestamp. If the database  140  timestamp is newer, it then reloads it&#39;s own cache  300  from the database  140 .  
         [0022]    In one embodiment, reloading the cache  300  is accomplished in the following manner. First, the application  101  and/or the virtual machine  330  disallows access to the cache  300 . In one embodiment, this is accomplished simply by toggling a Boolean variable (e.g., 1=cache access denied, 0=cache access permitted). However, various other techniques may be employed to deny access to the cache  300  while still complying with the underlying principles of the invention. In addition, the application  101  and/or the virtual machine  330  waits until all functions/methods which called into the cache  300  prior to detection of the cache reload requirement to finish processing. In one embodiment of the invention, this is accomplished via an access count variable that is incremented when each method of the cache  300  is called, and decremented when each method of the cache  300  completes (e.g., when the access count variable is zero, all method have completed). However, various other techniques may be employed to determine when all cache methods have terminated consistent with the underlying principles of the invention.  
         [0023]    Once it is determined that the access count variable is zero (e.g., once the cache object determines that all functions called prior to dirty cache detection have completed) the cache is reloaded. In one embodiment, the entire contents of the cache are dumped and a fresh set of data are reloaded from the database. The timestamp associated with the cache  300  is then set to be the same as the database  140  timestamp. In this manner, cached data will remain consistent across multiple applications  100 ,  101  and/or virtual machines  130 ,  330 .  
         [0024]    One embodiment of a method for synchronizing data across multiple virtual machines and/or applications is set forth in FIG. 5. At  500  an application attempts to access/modify data in its cache and as a result, at  502 , the timestamp in the database is compared with the cache timestamp. If the two timestamps are equal (determined at  504 ), then the cache is not out of date and, at  506 , the application is permitted to access/modify the data in the cache. At  508 , the data and timestamp in the database is also updated to reflect the changes in the underlying data and the time that the changes were made.  
         [0025]    If, however, the database timestamp and the cache timestamp are not equal, then the cache is out of date or “dirty” as indicated in FIG. 6, and must be reloaded (e.g., in FIG. 6 the timestamp of 12:00 is earlier than the database timestamp of 12:05). As a result, at  510 , access to the cache is denied. At  512  it is determined whether all functions called prior to the dirty cache detection have completed. If not, then the method loops through  514  and  512  until all functions have completed. Once all functions have completed, at  516 , the contents of the cache are dumped and the cache is reloaded. Finally, at  518  the timestamp is set to the same time as the timestamp in the database, resulting in synchronized caches as illustrated in FIG. 7.  
         [0026]    An exemplary computer system  800  representing clients and/or servers on which features of the invention may be performed will now be described with reference to FIG. 8. The computer system  800  comprises a system bus  820  for communicating information, and a processor  810  coupled to bus  820  for processing information. Computer system  800  further comprises a random access memory (RAM) or other dynamic storage device  825  (referred to herein as main memory), coupled to bus  820  for storing information and instructions to be executed by processor  810 . Main memory  825  also may be used for storing temporary variables or other intermediate information during execution of instructions by processor  810 . Computer system  800  also may include a read only memory (ROM) and/or other static storage device  826  coupled to bus  820  for storing static information and instructions used by processor  810 .  
         [0027]    A data storage device  827  such as a magnetic disk or optical disc and its corresponding drive may also be coupled to computer system  800  for storing information and instructions (e.g., Java applications/applets and virtual machine code). The computer system  800  can also be coupled to a second I/O bus  850  via an I/O interface  8230 . A plurality of I/O devices may be coupled to I/O bus  850 , including a display device  843 , an input device (e.g., an alphanumeric input device  842  and/or a cursor control device  841 ).  
         [0028]    The communication device  240  is used for accessing other computers (servers or clients) via a network, and uploading/downloading various types of data (e.g., Java applications/applets). The communication device  240  may comprise a modem, a network interface card, or other well-known interface device, such as those used for coupling to Ethernet, token ring, or other types of networks.  
         [0029]    Other embodiments of the invention may be implemented on cellular phones and pagers (e.g., in which the necessary transaction software is embedded in a microchip), handheld computing devices (e.g., personal digital assistants), and/or touch-tone telephones. It should be noted, however, that the underlying principles of the invention are not limited to any particular type of communication device or communication medium.  
         [0030]    Embodiments of the invention may include various steps, which have been described above. The steps may be embodied in machine-executable instructions which may be used to cause a general-purpose or special-purpose processor to perform the steps. Alternatively, these steps may be performed by specific hardware components that contain hardwired logic for performing the steps, or by any combination of programmed computer components and custom hardware components.  
         [0031]    Elements of the present invention may also be provided as a computer program product which may include a machine-readable medium having stored thereon instructions which may be used to program a computer (or other electronic device) to perform a process. The machine-readable medium may include, but is not limited to, floppy diskettes, optical disks, CD-ROMs, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, magnet or optical cards, propagation media or other type of media/machine-readable medium suitable for storing electronic instructions. For example, the present invention may be downloaded as a computer program product, wherein the program may be transferred from a remote computer (e.g., a server) to a requesting computer (e.g., a client) by way of data signals embodied in a carrier wave or other propagation medium via a communication link (e.g., a modem or network connection).  
         [0032]    Throughout this detailed description, for the purposes of explanation, numerous specific details were set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art that the invention may be practiced without some of these specific details. For example, while the embodiments described above focus on a Java virtual machine implementation, it will be appreciated that elements of the invention may be implemented in virtually any data sharing environment (e.g., the invention may be implemented with non-Java interpreted code engines). In certain instances, well known structures and functions were not described in elaborate detail in order to avoid obscuring the subject matter of the present invention. Accordingly, the scope and spirit of the invention should be judged in terms of the claims which follow.