Abstract:
There is provided a method and computer system for object persistency that includes: running a program; storing an object of the program into a random access memory in response to determining that the object is a non-persistent object; and storing the object into a phase change memory in response to determining that the object is a persistent object. The method and computer system of the present disclosure do not need separate persistency layers, such that the programming model is light weighted, the persistency of object data is more simple and fast, and implicit transaction process is supported, thereby a great deal of development and runtime costs are saved.

Description:
CROSS-REFERENCE TO RELATED FOREIGN APPLICATION 
       [0001]    This application is a non-provisional application that claims priority benefits under Title 35, Unites States Code, Section 119(a)-(d) from Chinese Patent Application having China Patent Application No. 201010524777.X, filed on Oct. 29, 2010, by Qing F. Wang and Yun Wang, which application is incorporated herein by reference in its entirety. 
       TECHNICAL FIELD 
       [0002]    The present disclosure relates to technical fields of electronic computation, data storage, and object-oriented program design and so on. 
       BACKGROUND 
       [0003]    Currently, object-oriented program design dominates all methods of program design. In the field of object-oriented program design, an object refers to an entity that has a state and a set of operations defined on the state. The state is represented as a set of object attributes. The set of operations associated with the object provide other objects (clients) which request services when requiring some computation with the requested services. Object classes are used to create objects. An object class definition serves as a template for objects which includes declarations of all attributes and services associated with an object of the class. Object persistency means that an object is stored into storage such that the object will not be lost even when power is down. In a JVM (Java Virtual Machine), an object is generally stored into a RAM heap which is volatile, that is, the object data stored in the RAM heap will be lost when the RAM heap is powered-down. Java is a trademark or registered trademark of Oracle and/or its affiliates in the United States, other countries, or both. 
         [0004]    An application usually needs to persist some, but not all, objects. Such persistency needs to go through a separate persistency layer. For example, a database usually includes a data portion and an interface such as an API (Application Programming Interface) which can be considered as the persistency layer. During exterior programming to access the database, in addition to statements for normal operations, the specific statements for persisting object data via the API are needed to be written. If such programming work is to be done for each of different databases, the workload is extremely enormous, and it is time consuming, exacting and error-prone. Thus, current object persistency methods and systems need separate persistency layers, heavy weight programming models, and high development and runtime costs. 
         [0005]    On the other hand, there has appeared PCM (Phase Change Memory). The PCM has characters in that it is data-nonvolatile and can be addressed according to bytes, which results in the storing speed of the PCM being very fast, and the PCM can be used as working memory (RAM) of CPU, and data can be stored persistently in the meantime. 
       SUMMARY 
       [0006]    According to one aspect of the present disclosure, there is provided a method for object persistency, comprising steps of: running a program; storing an object of the program into a random access memory in response to determining that the object is a non-persistent object; and storing the object into a phase change memory in response to determining that the object is a persistent object. 
         [0007]    According to another aspect of the present disclosure, there is provided a computer system, comprising: a processor which processes an object of a running program; a random access memory which stores the object in response to the processor determining that the object is a non-persistent object; and a phase change memory which stores the object in response to the processor determining that the object is a persistent object. 
         [0008]    With the method and computer system of the present disclosure, a separate persistency layer is no longer needed such that a programming model is light weighted, the persistency of object data is more simple and fast, and implicit transaction process is supported, thereby a great deal of development and runtime costs are saved. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0009]    These and/or other aspects and advantages of the present disclosure will become more apparent and more easily understood from detailed description of embodiments of the present disclosure in combination with the attached drawings, in which: 
           [0010]      FIG. 1  is a block diagram showing a computer system for object persistency according to the present disclosure; and 
           [0011]      FIG. 2  is a flow chart showing a method for object persistency according to the present disclosure. 
       
    
    
     DETAILED DESCRIPTION 
       [0012]    In the following, some specific embodiments of the present disclosure will be described in detail with reference to the attached drawings. If the detailed description of some related art may confuse the main points of the disclosure, the detailed description thereof will not be provided here. In respective embodiments, identical reference numbers are used to denote elements or units performing the same functions. 
         [0013]      FIG. 1  is a block diagram showing a computer system for object persistency according to the present disclosure. 
         [0014]    In  FIG. 1 , the reference number  100  is used to represent the computer system for object persistency of the present disclosure. The computer system  100  includes a RAM (Random Access Memory) heap  102  and a PCM (Phase Change Memory) heap  103  both of which are used herein as heaps (memories) for storing objects, wherein the RAM heap  102  is for volatile storage and the PCM heap  103  is for non-volatile storage. It can be seen from  FIG. 1  that Java threads (applications)  104  and  105  are run in the computer system  100  respectively. The computer system  100  of  FIG. 1  may further include a processor (or interpreter)  101 . Objects of the thread  104  or  105  are processed by the processor  101  of the computer system  100 , and they are stored into the RAM heap  104  or the PCM heap  105  based on conditions. 
         [0015]    Specifically, taking the thread  104  as an example, the processor  101  stores the object  111  in the thread  104  into the RAM heap  102  in response to judging that the object  111  does not need persistency, and stores the objects  112  and  113  in the thread  104  into the PCM heap  103  in response to judging that the objects  112  and  113  need persistency. The object  111  stored in the RAM heap  102  may further be called by other threads such as the thread  105 . Also, for the thread  105 , the respective objects  111 / 121  and  122 / 123  thereof can be stored into the RAM heap  102  and the PCM heap  103 , respectively. Specifically, the processor  101  stores the objects  111  and  121  in the thread  105  into the RAM heap  102  in response to judging that the objects  111  and  121  do not need persistency, and stores the objects  122  and  123  in the thread  105  into the PCM heap  103  in response to judging that the objects  122  and  123  need persistency. Since the PCM heap  103  not only can be accessed quickly, but also has a volatile feature, the purpose of persistency in the course of processing can be achieved. 
         [0016]    That is to say, the computer system  100  for object persistency provided by the present disclosure may include: the processor  101 , which processes an object of a running program; the RAM  102 , which is used to store the object in response to the processor  101  judging that the object is a non-persistent object; and the PCM  103 , which is used to store the object in response to the processor  101  judging that the object is an object which needs persistency. 
         [0017]    In addition to integration application of PCM on a physical machine, as shown in  FIG. 1 , according to one embodiment of the present disclosure, the computer system  100  may be implemented as a JVM (Java Virtual Machine). One highly important feature for an interpreted programming language (for example, Java) is independence of a platform. Use of a JVM is the key of achieving the feature. If a general advanced language is to be run on different platforms, it needs to be compiled into different target codes. However, after the JVM is introduced, the Java language does not need to be recompiled when running on different platforms. The usage mode of the Java language allows the JVM to shield information on specific platforms, such that a Java language interpreter only needs to generate target codes (byte-codes) running on the JVM so as to run on various platforms without modification. When executing byte-codes, the JVM interprets the byte-codes into machinery instructions on specific platforms to be executed. Therefore, since the present disclosure aims to the object persistency problem for object-oriented interpreted programming languages, the JVM can be selected as the target machine for PCM application in combination with the cross-platform feature of the JVM. 
         [0018]    The reference number  200  represents all kinds of applications, which can be run in the computer system  100  (for example, a JVM or interpreter therein), according to the present disclosure, in which one application is, for example, the following program example: 
         [0000]    
       
         
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 Class Student // One example 
               
               
                   
                 { 
               
             
          
           
               
                   
                 //_bP =true, the instance is set as persistency 
               
             
          
           
               
                   
                 public Boolean_bP; 
               
             
          
           
               
                   
                 //_bT =true, the instance is set as the transaction state 
               
               
                   
                  public Boolean _bT; 
               
             
          
           
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
         [0019]    In the above exemplary program, two attribute indicators are used to define object classes, wherein a transaction indicator bT is used to define whether or not the instance is involved in one transaction process, and a persistency indicator _bP is for defining whether or not the instance needs persistency. That is to say, the persistency indicator _bP is set to represent whether or not the object is an object that needs persistency, and the transaction indicator _bT is used to represent whether or not the object belongs to a certain transaction process. 
         [0020]    In the above exemplary program, when the object is determined to need persistency, that is, when the persistency indicator _bP is true, the object is stored persistently, that is, into the PCM heap  103 , otherwise, it is stored into the RAM heap  102 . When the object is determined to be one object in a certain transaction, that is, the transaction indicator _bT is true, the object is set as a transaction process mode. 
         [0021]    The present disclosure supports the transaction process mode. A transaction is a program executing unit which accesses and possibly updates various data items in a database, and it is usually caused by execution of a user program written with an advanced database manipulation language or a programming language (for example, Java) and is delimited by statements like “begin transaction” and “end transaction” (or a function call). A transaction is composed of all operations performed between “begin transaction” and “end transaction”. A transaction is a basic unit for resuming and concurrently controlling and has attributes such as atomicity, consistency, isolation, persistence and so on. 
         [0022]    A specific form of expression for a transaction programming model of the present disclosure may be for example as follows: 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 ObjA._bT = ObjB._bT = true 
                 // transaction process begins 
               
               
                   
                 ObjA.Update( ); 
               
               
                   
                 ObjB.Update( ); 
               
               
                   
                 ObjA._bT = ObjB._bT = false 
                 // transaction process ends 
               
               
                   
                   
               
             
          
         
       
     
         [0023]    Here, ObjA and ObjB are two related objects in the transaction, and updating thereof requires to be successful together or unsuccessful together. In the present disclosure, in order to achieve a simplified transaction programming model as described above, an enhanced Java interpreter (for example, the processor  101 ) needs to do the logical actions as follows: 
         [0000]    
       
         
               
             
               
               
             
               
             
               
               
             
           
               
                   
               
             
             
               
                 ObjA._bT = ObjB._bT = true // begin transaction, the object is copied 
               
             
          
           
               
                   
                 into the RAM heap 
               
             
          
           
               
                 ObjA.Update( ); // the copied object ObjA is updated 
               
               
                 ObjB.Update( ); // the copied object ObjB is updated 
               
               
                 ObjA._bT = ObjB._bT = false // end transaction, the copied object _bT 
               
             
          
           
               
                   
                 is set as false. 
               
               
                   
                   
               
             
          
         
       
     
         [0024]    The reference number  300  represents an object collector. An object collection mechanism refers to a mechanism that the computer system  100  uses to release memories occupied by those objects which are no longer used, and, thus, is also called a garbage collection mechanism. The Java language does not require a JVM to have an object collector and does not specify how the object collector works either. However, common JVMs all have object collectors, and most object collectors use similar algorithms to manage memories and to perform operations of collection. The purpose of object collection is to clear away objects which are no longer used. The object collector determines whether to collect an object or not by determining whether the object is referred by an active object or not. 
         [0025]    The object collector  300  of the present disclosure carries out the following logical operations to expand the object collector so as to achieve object access transfer between the RAM heap  102  and the PCM heap  103 , that is, to support transaction persistency. 
         [0026]    (1) if _bT is T (True), indicating that the object belongs to a certain transaction process, the object collector  300  performs no special processing on the object, and, instead, performs directly a normal flow of the object collector itself; 
         [0027]    (2) if _bT is F (False), indicating that the object does not belong to a certain transaction process, the object collector  300  further determines the attributes of _bP for the object, (2.1) if _bP of the object is T (True), indicating that the object needs persistency, the object collector  300  moves the object to the PCM heap  103  and performs conflict detection (transaction concurrency support); 
         [0028]    (2.2) if _bP of the object is F (False), indicating that the object does not need persistency, the object collector  300  moves the object to the RAM heap  102  and goes into a normal object collection flow (detection collection). 
         [0029]    The operations of the processor  101  and the object collector  300  of the present disclosure may be shown as the following table: 
         [0000]    
       
         
               
               
               
               
               
             
           
               
                   
               
               
                   
                   
                   
                 The operation of 
                 The operation of 
               
               
                 _bP 
                 _bT 
                 Heap 
                 processor 
                 object collector 
               
               
                   
               
             
             
               
                 T 
                 T 
                 PCM 
                 Copy the object into the 
                   
               
               
                   
                   
                   
                 RAM, update the copied 
               
               
                   
                   
                   
                 object 
               
               
                 T 
                 F 
                 PCM 
                   
                 Move the object to the 
               
               
                   
                   
                   
                   
                 PCM, conflict detection 
               
               
                 F 
                 T 
                 RAM 
                 Copy the object into the 
               
               
                   
                   
                   
                 RAM, update the copied 
               
               
                   
                   
                   
                 object 
               
               
                 F 
                 F 
                 RAM 
                   
                 Move the object to the 
               
               
                   
                   
                   
                   
                 RAM, object collection 
               
               
                   
               
             
          
         
       
     
         [0030]    In the object collector  300 , it is determined whether the RAM heap  102  or the PCM heap  103  is used by using the above two attribute indicators _bT and _bP and the transaction process between the RAM heap  102  and the PCM heap  103  is supported. 
         [0031]    When the attribute indicator _bT of the object is set as T (True), it indicates that the object belongs to a certain transaction process, and the object collector  300  does not operate on the object, instead, the processor  101  copies the object into the RAM heap  102  and updates the copied object, that is, performs an update process. When the attribute indicator _bT of the object is set as F (False), if the attribute indicator _bP of the object is set as T (True), it indicates that the object does not belong to a certain transaction process and needs persistency; at this time, the processor  101  does not operate, instead, the object collector  300  moves the object to the PCM heap  103  and performs conflict detection (transaction concurrency process). When the attribute indicator _bT of the object is set as F (False), if the attribute indicator _bP of the object is set as F (False) too, it indicates that the object does not belong to a certain transaction process and does not need persistency either, at this time, and the processor  101  does not operate, instead, the object collector  300  moves the object to the RAM heap  102  and performs an object collection process. The processor  101  and the object collector  300  according to the present disclosure may be implemented as identical or different machines, and the object collector  300  may be implemented in the computer system  100  for object persistency. 
         [0032]      FIG. 2  is a flow chart showing a method for object persistency according to the present disclosure. 
         [0033]    As shown in  FIG. 2 , a method for object persistency according to the present disclosure includes the following steps. At step ST 201 , a program, which may be various object-oriented applications, is run in the computer system  100  as shown in  FIG. 1 . At step ST 202 , it is determined whether or not the object is an object which needs persistency. At step ST 203 , the object is stored into a RAM in response to determining that the object of the program is a non-persistent object. At step ST 204 , the object is stored into a PCM in response to determining that the object is a persistent object. 
         [0034]    The respective steps as described above may be carried out by the processor  101  or other components or units in the computer system  100  as shown in  FIG. 1 . The method for object persistency according to the present disclosure may further include the step of setting a persistency indicator to indicate whether or not the object is a persistent object and setting a transaction indicator to indicate whether or not the object belongs to a transaction process. 
         [0035]    The method for object persistency according to the present disclosure may further include the step of moving the object to the RAM and performing a clearing process when the transaction indicator indicates that the object does not belong to a transaction process and the persistency indicator indicates that the object is a non-persistent object. 
         [0036]    The method for object persistency according to the present disclosure may further include the step of moving the object to the PCM and performing conflict detection when the transaction indicator indicates that the object does not belong to a transaction process and the persistency indicator indicates that the object is a persistent object. 
         [0037]    The method for object persistency according to the present disclosure may further include the step of copying the object to the RAM and performing update process when the transaction indicator indicates that the object belongs to a transaction process. 
         [0038]    The above embodiments of the present disclosure may be implemented by hardware, software and firmware or in a combination thereof, and the way of implementation is not limiting the scope of the present disclosure. For example, the present disclosure may be carried out by executing software programs according to the disclosure in a general purpose computer system. 
         [0039]    The above embodiments of the present disclosure are only exemplary description, and their specific structures and operations are not limiting the scope of the disclosure. 
         [0040]    Those skilled in the art can combine different parts and operations in the above respective embodiments to produce new implementations which equally accord with the conception of the present disclosure. 
         [0041]    The connection relationships between respective functional elements (units) in the embodiments of the present disclosure are not limiting the scope of the present disclosure, in which one or multiple functional element(s) or units may contain or be connected to any other functional elements or units. 
         [0042]    Although several embodiments of the present disclosure has been shown and described in combination with the attached drawings above, those skilled in the art should understand that various variations and modifications which still fall into the scope of claims and their equivalents of the present disclosure can be made to these embodiments without departing from the spirit and principle of the disclosure.