Data processing: database and file management or data structures – Database design – Data structure types
Reexamination Certificate
1999-02-10
2002-03-26
Breene, John (Department: 2177)
Data processing: database and file management or data structures
Database design
Data structure types
C711S118000
Reexamination Certificate
active
06363397
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Technical Field
The present invention relates to an object caching method, particularly to a data structure wherein classes of objects are hierarchically arranged in a plurality of levels, the caching of objects in the data structure, and the discarding of cached objects.
2. Prior Art
As the use of the Internet and Intranet has spread, various computer application programs are being executed in a distributed environment. In addition, object oriented techniques are being employed at the design and analysis stage for the development of application systems, and various data are being expressed as objects in the implementation and stored in distributed computers. Furthermore, computers, such as network computers (NCs) or portable PDAs, whose resources, such as main memories and computation capacities, are quite limited, are frequently being employed.
In such an environment, generally, a local terminal accesses to objects stored in a remote computer. However, taking into consideration the capacity of the terminal and the speed of a network, it is apparent that caching objects required by a terminal in the terminal is a good idea for a program that processes many remote objects. The required object, however, should not be cached as an individual object, but should be cached as one unit of objects constituting a network structure that will be accessed later. This reason can be derived from well-known characteristic of object oriented programming; that is, (1) a lot of messages are transmitted to objects during a process, and the objects which received the messages further may send messages to objects associated with themselves; and (2) as a result of repeating the above process, accesses to a lot of objects associated with each other is frequently performed.
Assume that one part of data in a database is employed as an object to be processed. In actual program development, specifically, legacy database systems are employed unchanged in many cases, and data in such a database can not be accessed as objects. Therefore, only data to be processed is converted into objects and they are copied to an accessible area. In this case, not only a single object but also the associated objects are required for the processing.
As described above, the procedure employed to determine which objects are to be cached has a great influence on the performance at the terminal. Some conventional methods for determining the range of objects to be cached will now be described.
In the object serialization in Java (trademark owned by Sun Microsystems), when a specific object is designated, basically, all the objects that can be reached from the object through references are to be serialized. The basic algorithm is as follows. If a reference to an object appears at the first time during the copying, a reference number is added to the object and the copying process is repeated recursively. As a reference to the same object appears, the number that was assigned to the object at the first appearance is transmitted instead of the object itself. In this manner, a network structure comprising objects that can be traced can be completely transmitted.
This method prevents the omission of objects, but predicting and controlling the quantity of data to be transmitted is difficult, and care should be taken when a network structure is transmitted that comprises many coupled objects. Java RMI (Remote Method Invocation) makes the control possible to a degree by using a transient value for the objects. However, since this is statically determined during the programming and can not be dynamically changed in accordance with various execution situations, this method lacks flexibility.
When the contents of a database are substantially converted into objects, a technique is employed where, although it depends on the architecture of the database system, a local pointer and a global pointer are used in the class definition to limit in advance the transfer range of the objects (see Container Object (“Data Model and C++ interface For Object Server Built Like Relational Database,” Fukuda et. al., 45th Information Processing Meeting (latter half of 1992) (4), p.4-111) and Entity/Dependent (“San Francisco Project Technical Summary,” IBM, http://www.ibm.com/Java/ Sanfrancisco)). However, it is difficult to dynamically change a target to be transferred and a transfer range each time processing is performed.
There is another method that employs a cluster concept to transfer all objects in an associated cluster substantially unchanged (see ObjectStore (“User Guide ObjectStore Release 3.0 For OS/2 and AIX/xlc System,” Object Design Inc., January 1994, pp. 42 to 44)). According to this method, a cluster is specified when an object is instantiated in a secondary storage. Actually, when a hardware page in the secondary storage and in a main memory is employed as a cluster unit, calculations performed by a CPU during the transfer, such as tracing of the object references, are not required, and then more efficient caching is provided. However, since the objects in the cluster are transferred unconditionally, unnecessary objects may be transferred, depending on a method for constructing the cluster. Particularly when much transfer time is required in a distributed environment, the volume of the data communication involved is increased and the performance is deteriorated. In addition, while this method provides control to a degree (it enables selection of a policy for caching) by the cluster unit, it cannot cope with dynamic changes of objects during the execution, especially changes on an object network after the objects are instantiated.
For an application program or a framework, object designers implement a method of caching. If they prepare a program very carefully, this program is quite flexible and provides satisfactory effects. However, this requires a high degree of programming skill, and in particular, it is difficult to maintain the consistency of the reference relationship in the cache when the cached objects are released.
If caching is forcedly released while the above described network structure composed of the objects is being cached, this leads to the illegal release of objects and to the illegal accesses to invalid objects. This occurs because an object can be shared by different network structures, and referencing from one network to another is also possible. Therefore, a special garbage collection procedure for maintaining the consistency is required.
A mechanism for detecting the accesses to objects outside the cache uses hardware or software hooking (see ObjectStore (“User Guide Object Store Release 3.0 For OS/2 and AIX/xlc System,” Object Design Inc., January 1994, pp. 9 to 11). In this system, the cache controller can detect such an access and invoke the cache routine without any extra control code in the application program.
The above described methods for determining the range of objects to be cached can not dynamically change objects to be cached in accordance with the various execution contexts.
Therefore, it is one object of the present invention to provide a method for dynamically changing objects to be cached in accordance with the various execution contexts.
It is another object of the present invention to provide a method for maintaining the consistency among whole cached objects even after the caching strategy changes dynamically.
It is an additional object of the present invention to provide a data structure in which objects to be cached can be dynamically changed.
It is a further object of the present invention to enable the customization of objects to be cached in accordance with the characteristic of an application program.
It is still another object of the present invention to reduce the dynamic calculation costs for determining objects to be cached.
SUMMARY OF THE INVENTION
First, an explanation will be given for a data structure which enables to dynamically change objects to be cached. At the least, classes of objects in the data structure is hierarchically arranged in a
Breene John
Rayyan Susan
Scully Scott Murphy & Presser
Zarick, Esq. Gail H.
LandOfFree
Method for selecting objects to be cached, method for... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method for selecting objects to be cached, method for..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method for selecting objects to be cached, method for... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2874559