JP2009157805A - Object cache construction method, object cache construction program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To construct an object cache on a memory of a computer, to increase speed of access to the cache itself, and to maintain data consistency. <P>SOLUTION: In a method for constructing the object cache on the memory of the computer, when an object for cache is stored in a cache area, the object for cache is divided into a referred object representing the content of the object for cache and a referring object holding reference information turned to the referred object to store the objects in the cache area. When an access request to the stored referred object is accepted, the reference turned to the referred object is returned via the referring object, and the reference is used to indirectly access the referred object. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a method for constructing an object cache on a memory of a computer and a program therefor.

When accessing data from an application executed on a computer, a method of constructing a cache of target data on a memory is often used as means for speeding up the access.
For example, there are the following methods for classifying caches used by applications.

(1) DB cache By copying a data body with high access frequency and a processing program with high execution frequency to a cache area, the access speed to the database is increased. In general, a cache used by an application often refers to this DB cache.

(2) Object cache When a binary object is deposited on a cache area and associated with a predetermined key and used later by an application, the binary object is directly accessed by specifying the key.
When the same binary object with a relatively large size is used many times, the load to generate the same object many times can be reduced by using the binary object stored in the cache area repeatedly. Suitable for use.
As a specific implementation example, the binary object to be stored and the hash key are associated and stored in the hash mapping area, the hash key is specified from the application, and the associated binary object is acquired. There is a technique.

  In addition, regarding the cache on the memory of the computer, “speeding data access from an application while maintaining data consistency and saving memory area”. As a technology for the purpose of the above, “the cache control unit 15 of the mobile terminal 10 receives an access request to an instance of an object that defines data referred to by the application 13, and if there is no instance of the object, And create a counter. Also, an instance of the reference setting class is generated, a reference for referring to the requested object instance is set and returned to the application 13, and the counter is incremented by one. When the release notification of the instance of the reference setting class is received, the corresponding counter is decremented by 1, and the object instance is released when the counter reaches 0. Is proposed (Patent Document 1).

  Further, regarding an object cache, “a cache system capable of efficiently storing cache data is provided. As a technology for the purpose, "High-efficiency cache system is a high-efficiency cache system in object-relational mapping, and converts data stored in the relational database into cache objects and processing objects. Data object conversion means, object correspondence mutual conversion means capable of converting the cache object and the processing object in association with each other, object cache storage means for storing the cache object, and data from the relational database Replenishment object data acquisition means for acquiring the cache object and processing object provided for the acquisition request from the acquired object and the acquired data And a object generation means for generating and. Is also proposed (Patent Document 2).

JP 2005-190221 A (summary) JP 2007-265164 A (summary)

The technique described in Patent Document 1 relates to a technique for speeding up object access of the mobile terminal 10 by constructing a cache, and is described from the viewpoint of contributing to the convenience of the application by using the cache from the application. Yes.
This can be said to describe the technique close to the DB cache of (1) according to the above-described cache classification method.

  Further, although the technique described in Patent Document 2 refers to the object cache, its use is close to the DB cache of (1), and the cache format is merely an object type.

  On the other hand, there has been a demand for speeding up and maintaining data consistency for the object cache itself. However, with the techniques described in Patent Document 1 and Patent Document 2, the speed of the cache itself and data consistency are improved. The details of the maintenance are not described, and a cache construction method that enables this is desired.

  The present invention has been made to solve the above-described problems, and has an object to construct an object cache on a memory of a computer, to speed up access to the cache itself and to maintain data consistency. To do.

  An object cache construction method according to the present invention is a method of constructing an object cache on a memory of a computer, the step of securing a cache area on the memory, the step of storing a cache target object in the cache area, Receiving an access request for the stored cache target object, and when the cache target object is stored in the cache area, the cache target object is referred to as a referenced object representing the content of the cache target object itself; The reference object that holds the reference information for the referenced object is divided and stored in the cache area, and when an access request for the stored referenced object is received, Via the serial reference object returns a reference directed to the referenced object is intended to be accessed indirectly the referenced object using the reference.

According to the object cache construction method of the present invention, when an object is stored in the cache, the object is divided into a referenced object and a reference object, and the referenced object is accessed via the reference object. Can be prevented from accessing one updating object at the same time, and data consistency is ensured.
Also, when multiple objects are associated and stored in the cache area, each association can be divided and stored, making it easy to retrieve only the acquisition target object, There is no need to obtain it together.
Therefore, the memory area consumed at the time of one object access can be suppressed, so that the object access can be speeded up.

Embodiment 1 FIG.
FIG. 1 is a configuration diagram of an object cache according to Embodiment 1 of the present invention.
In FIG. 1, a cache area 100 is a certain area secured on the memory of a computer, and is internally divided into a reference object area 110 and a referenced object area 120.
The reference object area 110 and the referenced object area 120 can be constructed using a collection area such as a hash map or an array area, for example. These areas will be described later with reference to FIG.
For implementation, the referenced object area 120 may be held in the reference object area 110. In the first embodiment, for convenience of description, it is represented as shown in FIG. The same applies to the following embodiments.

  The reference object area 110 and the referenced object area 120 constructed on the cache area 100 correspond to the object cache in the narrow sense in the first embodiment, and a cache manager 200 is added to this to provide means for storing and acquiring objects. What is added corresponds to the object cache in a broad sense in the first embodiment.

The cache manager 200 and the application 300 are programs on a computer that store the cache area 100 in a memory, and are executed on an arithmetic device such as a CPU (Central Processing Unit) or a microcomputer (not shown).
The cache manager 200 secures the cache area 100 on the memory of the computer, stores the object in the cache area 100, or acquires the object stored in the cache area 100 in response to a request from the application 300. More details will be described later with reference to FIG.
The application 300 stores an object in the cache area 100 or acquires an object stored in the cache area 100 via the cache manager 200.

FIG. 2 shows an image for storing an object in the cache area 100.
FIG. 2A illustrates a relationship model in the case where the entity A and the entity C are related by the relationship B.
FIG. 2B represents the related model of FIG. 2A with an object model. In the object model, the relation B is also expressed as an object. In this case, object A and object B are associated with each other in a reference relationship, and object B and object C are associated with each other in a reference relationship.

FIG. 2C shows a state in which each object in FIG. 2B is stored in the object cache according to the first embodiment.
In the conventional object cache, each object in FIG. 2B is stored in the cache area 100 as it is. In the object cache according to the first embodiment, each object in FIG. 2B is referred to as a “reference object”. It is divided into two types of objects called “referenced objects” and stored.
“Reference object” is stored in the reference object area 110, and “referenced object” is stored in the referenced object area 120.

The reference object holds reference information for the corresponding referenced object.
The referenced object is referenced from the corresponding reference object and holds reference information for the reference object corresponding to the associated object.

In the example of FIG. 2C, the referenced object B is referred to the reference object A (“RefA” in FIG. 2C) and the reference object C (“RefC” in FIG. 2C). Keep information.
The referenced object A and the referenced object C hold reference information for the reference object B (“RefB” in FIG. 2C).

In order to access the referenced object stored in the cache area 100, the referenced object must be passed through, and the referenced object cannot be directly accessed. This is different from an object cache implemented using a normal hash key.
A more detailed object acquisition procedure will be described later with reference to FIG.

  FIG. 3 illustrates a procedure when the application 300 deposits a new object A in the cache area 100. Hereinafter, each step of FIG. 3 will be described.

(1) The application 300 generates an object A to be stored in the cache area 100. At this time, the unique identification key of the object A is stored in the member variable of the object A.
(2) The application 300 requests the cache manager 200 to deposit the object A in the cache area 100.
(3) The cache manager 200 divides the object A into the reference object A and the referenced object A, and stores them in the respective areas. At this time, reference information for the referenced object A is stored in the reference object A.

Note that the reference object area 110 and the reference objects in the reference object area 110 are loosely connected with a weak reference. Therefore, when the reference object is no longer referred to by any other object, the reference object is automatically deleted from the reference object area 110.
The same applies to the connection between the referenced object region 120 and the referenced object in the area.
For example, when an object is actually deleted from each area, garbage collection (Garbage Collection) is executed in the execution environment of the cache manager 200 can be a candidate.

  As described above, the object stored in the cache area 100 is determined to be unnecessary when it is no longer referred to by another object, and is deleted from the cache area 100. Therefore, the reference object area 110 and the referenced object area 120 can serve as a pseudo-cache.

  FIG. 4 illustrates a procedure for accessing an object stored in the cache area 100. Hereinafter, each step of FIG. 4 will be described.

(1) The application 300 requests the cache manager 200 to acquire the referenced object B.
(2) The cache manager 200 does not return the referenced object B itself, but newly generates a reference object B and returns it to the application 300. At this time, internally, a clone of the referenced object B stored in the referenced object area 120 is generated and set to be referenced from the newly generated reference object B.

(3) The clone of the referenced object B is copied and held as it is with respect to the reference object A and the reference object C held by the clone-referenced object B.

In step (3), the reference information held by the clone of the referenced object B is a reference in only one direction from the clone B toward the reference object A and the reference object C.
As described above, the reference information held by the clone B is set to only one direction so that the application 300 is not accessed from another application while the application 300 is changing the clone of the referenced object B. It is to do.
That is, if other reference information is generated and can be referred to in the direction from the reference object area 110 to the clone B, the reference is traced and another application is applied to the clone of the referenced object B being changed. This is because there is a possibility of reaching.

  Thereafter, the application 300 performs various processes such as acquisition of a value held by the referenced object B via the new reference object B received from the cache manager 200, for example.

The difference between “reference information” and “identification key” will be supplemented here.
The “reference information” is pointer information for the reference destination object, and the cache manager 200 and the application 300 can directly reach the reference destination object by acquiring the reference information. For example, in the case of Java (registered trademark) language, it is realized by the Reference class and its subclass.
The “identification key” is a unique identification ID of the object, and corresponds to a “primary key” in the relational database or a hash key in a hash index. The cache manager 200 and the application 300 can indirectly acquire the reference destination object by designating the “identification key”.

The object cache according to the first embodiment is useful if the object to be acquired can be acquired, so it is not necessary to acquire other related objects together, but it is necessary for the processing of the application 300. For example, since the clone of the referenced object B holds the reference relationship toward the reference object A and the reference object C in the reference object area 110, the object can be reached by following this.
However, it is added that tracing the object reference relationship one after another in this way is not the original use of the object cache according to the first embodiment.

If the application 300 is accessing a clone of the referenced object B and another application requests access to the referenced object B stored in the cache area 100, the other application A new clone of the referenced object B is acquired by the same procedure as in FIG.
Accordingly, the clone of the referenced object B accessed by the application 300 is not accessed by another application, and it is guaranteed that the clone of the referenced object B is not accessed in an unstable state during update.

In other words, it can be said that the “Read Committed” isolation level as performed on the database is realized in the object cache according to the first embodiment.
That is, an object in an unstable state being updated is never accessed, which means that an object accessed from the application 300 is guaranteed to be updated. This is the “Read Committed” isolation level itself.

As described above, according to the example described in the first embodiment, when the cache manager 200 stores an object (assumed to be object B) in the cache area 100, the cache manager 200 stores the reference object B and the referenced object B. The object is divided and stored in each area, and the referenced object B is accessed via the reference object B.
As described above, by adopting the divided object storage structure, it is sufficient to return only the reference object B for the access request, and it is not necessary to return all related objects.

Further, according to the example described in the first embodiment, when the cache manager 200 receives an access request for the referenced object B from the application 300, the cache manager 200 generates a clone of the referenced object B and a new reference object B. Then, a new reference object B is returned to the application 300.
At this time, only one-way reference information directed to the reference destination object is copied to the clone of the referenced object B.
The reference information from the reference object area 110 to the clone B is not copied to the clone B because the copy source object does not hold such reference information in the first place.
This prevents other applications from accessing the object while the application 300 is updating the clone of the referenced object B.

Even if a plurality of applications request access to the referenced object B, other applications do not access the same object while each application is updating the referenced object B (clone thereof).
Thereby, the “Read Committed” isolation level is realized in combination with the method in which only the one-way reference information is stored in the clone B.
That is, according to the object cache according to the first embodiment, it is possible to reliably maintain consistency of stored data.

Embodiment 2. FIG.
In the first embodiment, the application 300 requests the cache manager 200 to acquire the referenced object B stored in the cache area 100, and the cache manager 200 generates a clone of the referenced object B to generate the reference object B. Explained to return.
In the second embodiment of the present invention, a procedure for reflecting and confirming changes made to the clone of the referenced object B in the cache area 100 will be described. Note that each configuration related to the object cache is the same as that of the first embodiment, and thus the description thereof is omitted.

  FIG. 5 illustrates a procedure in which changes made by the application 300 to the clone of the referenced object B are reflected in the cache area 100 and confirmed. Hereinafter, each step of FIG. 5 will be described.

(1) Generating and Returning Reference Object B The application 300 can indirectly access the clone of the referenced object B by the same procedure as steps (1) to (3) in FIG.
Next, the application 300 changes the value held by the clone of the referenced object B through the newly generated reference object B.

(2) Replacing with Reference to the Clone of Object B The application 300 requests the cache manager 200 to reflect the change made to the clone of the referenced object B in the cache area 100 and confirm it. This corresponds to a commit request in the database.
The cache manager 200 receives the request, and replaces the reference information of each object in the reference object area 110 with the reference information with the clone of the referenced object B.
As a result, the referenced object B in the referenced object area 120 is logically replaced with a clone of the referenced object B.

In the example of FIG. 5, the reference information of the reference object B is replaced with information for the clone of the referenced object B.
As a specific implementation example when replacing reference information, there is a method of calling a method of a reference source object with a reference destination object as an argument.

(3) The original object is to be deleted The referenced object B that was previously stored in the referenced object area 120 still holds reference information for the reference object A and the reference object C ( (It is not shown in FIG. 5), and itself is not referred to by any object.
Therefore, the referenced object B previously stored in the referenced object area 120 becomes a target to be deleted from the cache area 100 and is automatically deleted later.

  In step (2), while the cache manager 200 is changing the reference information of each object in the reference object area 110 (corresponding to the commit), the cache manager 200 is configured so that other applications do not access the cache area 100. The area 100 is locked by the cache manager 200.

As described above, according to the second embodiment, when the cache manager 200 reflects the change made by the application 300 on the clone of the referenced object B in the cache area 100 and determines the change, the reference object The confirmation process is executed by rewriting the reference information of the reference object B stored in the area B to the reference information for the clone of the referenced object B.
For this reason, the process of determining the reflection to the cache area 100 is completed in a very short time, so that the time for locking the cache area 100 can be shortened and the simultaneous accessibility of applications can be improved.

Embodiment 3 FIG.
In the second embodiment, the procedure for reflecting and confirming the change made to the clone of the referenced object B in the cache area 100 has been described.
In the third embodiment of the present invention, a procedure will be described in which, when an object is stored in the cache area first, a new object associated with the object is added and reflected in the cache area 100 for confirmation. Note that each configuration related to the object cache is the same as that in the first and second embodiments, and thus the description thereof is omitted.

FIG. 6 shows a state in which a new entity C is associated with an existing entity A with a relationship B using a relationship model.
6A shows the state before the addition of the entity C, and FIG. 6B shows the state after the addition of the entity C.
Next, the procedure for performing the addition on the relation model on the object cache according to the third embodiment will be described with reference to FIGS.

FIG. 7 shows how the application 300 acquires the referenced object A stored in the cache area 100.
The cache area 100 stores a reference object A and a referenced object A corresponding to the entity A in FIG.
The application 300 first acquires the object A in the cache area 100 when generating the object B and the object C corresponding to the relationship B and the entity C. The acquisition procedure is the same as that described in FIG. 4B of the first embodiment.
The cache manager 200 creates a clone of the referenced object A and returns the newly created reference object A to the application 300.
The application 300 can access the clone of the referenced object A via the received reference object A.

FIG. 8 shows a state in which the application 300 generates a newly added object C and a related object B representing the relationship.
The related model described with reference to FIG. 6B is expressed by associating the object A and the object C with the related object B as described with reference to FIG. Therefore, the application 300 newly generates an object B and an object C in addition to the clone of the referenced object A acquired in the procedure of FIG.

  At this time, the application 300 generates the object B and the object C by dividing them into a reference object and a referenced object according to the object storage structure in the present invention. Each reference object holds reference information directed to the corresponding referenced object.

As in the case of depositing a single object in the cache area 100, only the referenced object may be generated and deposited in the cache manager 200, and the cache manager 200 may generate the reference object.
Here, for convenience of explanation, it is assumed that both the referenced object and the reference object are generated on the application 300 side.

Further, the following reference relationship is held as a logical reference using the identification key of the reference destination object.
(1) Reference relationship between reference object B and referenced object A / C (2) Reference relationship between referenced object B and reference object A / C

  Regarding the reference relationship of (1) and (2) above, reference information is not held but only logical reference using an identification key is used when other objects are stored when storing these objects in the cache area 100. This is to prevent the access to each object by tracing the reference information.

FIG. 9 shows a state in which each object acquired and generated by the application 300 is reflected in the cache area 100.
The application 300 requests the cache manager 200 to reflect each object in the cache area 100. This corresponds to a commit request in the database.
The cache manager 200 reflects each object in the cache area 100 in the following procedure.

(1) The cache manager 200 stores the reference / referenced object B and the reference / referenced object C in each area of the cache area 100.

(2) The cache manager 200 rewrites the reference information of the reference object A previously stored in the reference object area 110 with the reference information for the clone of the referenced object A.
As a result, the referenced object A in the referenced object area 120 is logically replaced with a clone of the referenced object A.

(3) The cache manager 200 holds the “Non-repeatable read” flag in the reference object A in the reference object area 110 while executing the above steps (1) to (2).
This is a flag for notifying other applications that “Non-repeatable read” may occur even if the reference object A is accessed at this time.
When an access request for an object holding the flag is received, the contents of the flag are returned.

FIG. 10 shows how changes made to the cache area 100 are confirmed.
The cache manager 200 confirms the changes made to the cache area 100 by executing the processes shown in FIG. 10 following the process of FIG. Hereinafter, each step of FIG. 10 will be described.

(1) The cache manager 200 rewrites the logical reference by the key reference between the objects in the cache area 100 to the direct reference using the reference information.
(2) When the above processing is completed, the cache manager 200 clears the “Non-repeatable read” flag held in the reference object A in the reference object area 110.

(3) The referenced object A previously stored in the referenced object area 120 is not referred to by any object. Therefore, the referenced object A previously stored in the referenced object area 120 becomes a target to be deleted from the cache area 100 and is automatically deleted later.

  Through the above procedure, in addition to the object A previously stored in the cache area 100, an object B and an object C are newly added, and the relational model described in FIG. 6B is reflected on the cache area 100.

Note that “Non-repeatable read” means that when an object acquired by the application is acquired again, another application changes the object and fixes it in the cache area 100, so that the new object is not the previous object. A state where an object is acquired.
9 to 10, the cache manager 200 is in the process of confirming the reflection to the cache area 100 (corresponding to the commit state), so that another application accesses the cache area 100 in this state. However, when accessing again, the contents are different. This can be said to be a state where “Non-repeatable read” can occur.

As described above, according to the third embodiment, the application 300 acquires a clone of the object A previously stored in the cache area 100, newly generates the object C and the related object B, and The cache manager 200 is requested to store the object in the cache area 100.
With this operation, an arbitrary relation can be added to the object in the existing cache area 100.

Further, according to the third embodiment, after storing each object in the cache area 100, the cache manager 200 rewrites the logical reference based on the key reference between the objects to the direct reference using the reference information.
That is, the reference object A / C holds the reference information for the reference object B, and the reference object B holds the reference information for the reference object A / C.
As a result, while the change to the cache area 100 is being reflected, the object being changed is not reached from another application, and data consistency is maintained.

Further, according to the third embodiment, the cache manager 200 sets the “Non-repeatable read” flag to the reference object in the reference object area 110 while the change is confirmed by reflecting the change to the cache area 100. If there is an access to the object from another application, information corresponding to the contents of the flag is returned.
As a result, other applications can recognize that the cache area 100 is being updated, and can take appropriate measures such as performing error processing or waiting for a certain period of time.

Embodiment 4 FIG.
In the third embodiment, the procedure for generating a new object C, associating with the related object B with the object A, and reflecting and confirming in the cache area 100 has been described.
In the fourth embodiment of the present invention, a procedure for deleting the object added in the third embodiment from the cache area 100 and returning to the state before the object addition will be described. Note that each configuration relating to the object cache is the same as in the first to third embodiments, and thus the description thereof is omitted.

FIG. 11 shows the first step of deleting the object C in the cache area 100.
The application 300 requests the cache manager 200 to delete the object C in the cache area 100.
The cache manager 200 generates a clone of the object B that associates the object A and the object C, generates a corresponding reference object B, and returns it to the application 300. This procedure is the same as that described in FIG. 4B of the first embodiment.

FIG. 12 shows a step of reflecting the clone of the referenced object B in the cache area 100.
The application 300 requests the cache manager 200 to reflect the clone of the referenced object B acquired in FIG.
The cache manager 200 rewrites the reference information of the reference object B stored in the reference object area 110 with the reference information for the clone of the referenced object B.
As a result, the referenced object B in the referenced object area 120 is logically replaced with a clone of the referenced object B.

The clone of the referenced object B holds reference information for the reference object A / C in the reference object area 110.
Also, the referenced object B that is the origin of the clone still holds reference information for the reference object A / C in the reference object area 110.
Therefore, at this point, the reference object A / C is not deleted from the cache area 100 because it is referenced from the referenced object B.

Note that the cache manager 200 holds a “Phantom read” flag in the reference object B in the reference object area 110.
This is a flag for notifying other applications that “Phantom read” may occur even if the reference object B is accessed at this time. The contents of “Phantom read” will be described later.
When an access request for an object holding the flag is received, the contents of the flag are returned.

  FIG. 13 shows a step of deleting reference information from the referenced object A / C toward the reference object B. Hereinafter, each step of FIG. 13 will be described.

(1) The cache manager 200 deletes the reference information from the referenced object A / C toward the reference object B. Further, the reference information directed to the referenced object A / C is deleted from the clone of the referenced object B.
(2) On the other hand, the referenced object B that is the origin of the clone is not referenced by any other object, and is therefore a deletion target from the cache area 100.

14 to 16 show how the objects to be deleted are sequentially deleted from the cache area 100. FIG. Each figure will be described below.
It is assumed that the referenced object A in the referenced object area 110 is referred to by another object (not shown) and is not a deletion target.

In FIG. 14, the referenced object B that is the source of the clone is deleted from the cache area 100.
Further, the reference object B in the reference object area 110 is not referenced by any other object, and is therefore a deletion target from the cache area 100.
Furthermore, the reference object B received by the application 300 from the cache manager 200 is deleted when the application 300 ends.
When the application 300 and the reference object B disappear, the clone of the referenced object B is not referred to by any other object, and becomes a target to be deleted later.

In FIG. 15, the clones of the reference object C and the referenced object B are deleted from the cache area 100.
In addition, the referenced object C is not deleted from any other object, and is later deleted.

FIG. 16 shows the final state in the cache area 100.
Eventually, in the cache area 100, the reference object A referred to by another object (not shown) and the referenced object A referenced from the reference object A are left without being deleted.

Through the above procedure, the state in the cache area 100 is returned to the same state as in FIG.
This corresponds to the related model described in FIG.

Note that “Phantom read” means that when a set of objects previously acquired by an application is acquired again under the same conditions, those objects are changed by another application and confirmed in the cache area 100, so that the same conditions are satisfied. A state in which a previous object set cannot be obtained even if a set of objects is acquired.
In the state of FIGS. 12 to 13, even if another application accesses the reference object B being deleted by the cache manager 200, the object is deleted after that, so even if it is accessed again The same result may not be obtained.
This can be said to be a state where “Phantom read” can occur.

As described above, according to the fourth embodiment, the cache manager 200 acquires a clone of the related object B stored in the cache area 100 first, and logically matches the related object B stored previously. Replace with.
With this operation, an object that is referred to only from the related object B is not referenced from any other object, and is deleted from the cache area 100.

Further, according to the fourth embodiment, the cache manager 200 deletes the reference information for the reference object B.
As a result, the related object B itself is not referred to by any other object, and is deleted from the cache area 100.

Further, according to the fourth embodiment, the cache manager 200 holds the “Phantom read” flag in the reference object B in the reference object area 110 during the deletion process of the object B / C. If there is an access to the object from another application, information corresponding to the contents of the flag is returned.
As a result, other applications can recognize that the cache area 100 is being updated, and can take appropriate measures such as performing error processing or waiting for a certain period of time.

Embodiment 5 FIG.
In the first to fourth embodiments, when the process such as change / addition / deletion performed on each object is reflected in the cache area 100 and determined (corresponding to a commit), the cache manager 200 sets the cache area 100 Explained to lock.
However, although the finalizing process ends instantaneously, if the entire cache area 100 is locked, parallel accessibility to objects in the cache area 100 is lowered, and the cache performance as a whole may be lowered.

  In the fifth embodiment of the present invention, a method for locking only a part of the cache area 100 will be described. Note that each configuration related to the object cache is the same as that of the first to fourth embodiments, and thus description thereof is omitted.

FIG. 17 illustrates the lock range of the cache area 100 according to the fifth embodiment.
In the fifth embodiment, when reflecting a change or the like in the cache area 100, the cache manager 200 locks only the target object and its surrounding objects, and other objects can be accessed in parallel from other applications. Keep it like that.

The lock range in the fifth embodiment can be set as follows, for example.
(1) Lock all change target objects and subordinate objects referenced from the objects. Therefore, the lock range varies with each update.
(2) When the cache area 100 is fixedly divided into a plurality of areas in advance and an object in the area is updated, the corresponding area is set as a lock range.

As described above, according to the fifth embodiment, the cache manager 200 does not lock the entire cache area 100 when confirming the changes made to each object stored in the cache area 100. Instead, only a limited area is locked.
For this reason, the object stored in the unlocked area can be accessed in parallel by other applications, so that the simultaneous effectiveness of the application is improved and the performance as an object cache is improved.

Embodiment 6 FIG.
In the sixth embodiment of the present invention, a method for speeding up the processing when acquiring a plurality of objects by tracing the reference relationship of objects stored in the cache area 100 will be described.
First, the principle operation when acquiring a plurality of objects from the object cache (the entity is the cache area 100) according to the present invention will be described, and then the object acquisition operation according to the sixth embodiment will be described.
Note that each configuration related to the object cache is the same as that of the first to fifth embodiments, and thus description thereof is omitted.

  FIG. 18 illustrates a principle procedure when acquiring a plurality of objects from the cache area 100. Hereinafter, each step of FIG. 18 will be described.

(1) Tracing the reference relationship The application 300 requests the cache manager 200 to acquire the referenced object B. The cache manager 200 generates a clone of the referenced object B in the same procedure as in FIG. 4 (2), and returns the newly generated reference object B to the application 300.
The application 300 traces the reference information held by the clone of the referenced object B, and knows that the reference destination object is the reference object C.

(2) Acquiring Referenced Object The application 300 requests the cache manager 200 to acquire the referenced object C that is the reference destination of the clone of the referenced object B. The cache manager 200 generates a clone of the referenced object C in the same procedure as (1), and returns the newly generated reference object C to the application 300.

  Thereafter, by repeating the same procedure, the application 300 can sequentially acquire a plurality of objects stored in the cache area 100 while tracing the reference information.

Here, in FIG. 18B, attention is paid to the fact that the clone of the referenced object is generated every time the application 300 acquires the referenced object.
The clone of the referenced object is created to prevent other applications from accessing the referenced object being operated, and it is effective for that purpose. This method may be inconvenient when acquiring.

Since the process of creating an object clone is nothing but creating a new object, it consumes a certain amount of memory area and CPU resources.
When a large number of objects are acquired, there is a concern that these may be stacked, resulting in a decrease in speed performance as a whole.

  Therefore, in the sixth embodiment, a procedure for acquiring a plurality of objects while performing direct reference using reference information while avoiding clone generation of the referenced object as much as possible will be described.

  FIG. 19 illustrates a procedure for acquiring a plurality of objects from the cache area 100 in the sixth embodiment. Hereinafter, each step of FIG. 19 will be described.

(1) Acquiring Reference Object B The application 300 requests the cache manager 200 to acquire the referenced object B. The cache manager 200 returns the newly generated reference object B to the application 300 in the same procedure as in FIG. 4 (2) and FIG. 18 (1).

(2) Generating and sending an agent The application 300 creates an agent object that collects objects in the cache area 100 and sends it to the cache area 100 via a clone of the reference object B-> referenced object B.
As a specific implementation example when sending the agent object, a method of calling the method of the reference object C in the reference object area 110 using the generated agent object as an argument can be considered.
Thereafter, similarly, by sequentially calling the method of the reference destination object with the agent object as an argument, the agent object circulates in the cache area 100 and the attribute value of each object is collected.

Compared with the basic acquisition procedure described with reference to FIG. 18, this method does not perform object generation except that the clone of the referenced object B and the agent object are first generated. From the viewpoint of load, it is much more advantageous than the example of FIG.
Therefore, even when the application 300 acquires a large number of objects, there is no concern that the speed performance is degraded.

Such a method of adding a function to a counterpart object by delivering an object having a function that the counterpart object does not hold (an object collection function in the sixth embodiment) is a design pattern generally called a “visitor pattern”. Known as.
However, the “Visitor pattern” refers to a general object design method and is defined for general purposes, whereas in the present invention, the object collection using the reference relationship between objects is performed. However, it can be said that this is a unique method different from the general “Visitor pattern”.

FIG. 20 compares and explains the difference in memory usage between the conventional cache and the object cache according to the sixth embodiment.
FIG. 20A shows the usage status of a memory in a conventional cache. In the conventional cache, when acquiring all related objects using a certain object as an entrance, all the related objects are cloned on the application 300 side.
In this case, since all related objects are instantiated, this has been a factor in pressing the memory area of the application.

FIG. 20B shows the object collection operation status of the object cache according to the sixth embodiment.
As described with reference to FIG. 19, when generating a plurality of objects in the cache area 100, only the clone of the object that is the entrance is generated, and the agent object is sent using this as the entrance. There is no need to generate the memory, which is advantageous from the viewpoint of memory usage.

As described above, in the sixth embodiment, when a plurality of objects in the cache area 100 are acquired, the agent object is sent into the cache area 100 via the object serving as an entrance.
This technique can improve the performance of the object cache from the viewpoint of both access speed and memory usage.

Embodiment 7 FIG.
In the sixth embodiment, the method for collecting the objects in the cache area 100 at high speed using the agent object has been described.
In the seventh embodiment of the present invention, the agent object collection conditions will be described more specifically.

When the agent object acquires all the objects in the cache area 100, no special measures are required. However, when collecting only objects that meet a certain condition, information corresponding to the search condition is displayed. Need to be passed to the agent object.
Therefore, in the seventh embodiment, the property file defining the search conditions for the agent object is passed under the cache manager 200.
The following information (1) and (2) is described in this property file.

(1) Collecting by specifying at least one of the type / stereotype of the object to be collected and specifying the type / stereotype of the object to be collected means the following, for example.
(1.1) The class type of the collection target object is specified in the property file. For example, the usage is such that only the “Account” class and its subclasses are collected.
(1.2) << control >>>> Only a stereo type object is collected.
(1.3) Specify both of the above as collection conditions.

(2) Direction of travel of agent object Specifying the direction of travel and collecting means to specify in which direction the agent object proceeds when there are a plurality of object reference destinations.
The object reference relationship is known on the application 300 side when depositing an object in the cache area 100, and based on this, the application 300 side specifies in which direction the collection should be performed. .

  As described above, in the seventh embodiment, the search condition is separated from the agent program as a property file, so that various patterns of data can be collected by one agent.

Embodiment 8 FIG.
In the above first to seventh embodiments, the cache manager 200 sets the “Non-repeatable read” flag and the “Phantom read” flag to the object, for example, while the reference information of the object in the cache area 100 is being replaced. I explained that it was kept.
How the application 300 behaves when the application 300 acquires the contents of these flags depends on the policy of the transaction at that time.

  As one implementation example, a method of generating a connection object for connecting the application 300 and the cache manager 200 and setting a policy related to the behavior when the above-described flag is received is set in the connection object. Can be considered.

Embodiment 9 FIG.
In the first to eighth embodiments described above, the object cache entity according to the present invention is the cache manager 200 and the cache area 100.
As an implementation form of the cache manager 200, for example, the following can be considered.

(1) The cache manager 200 is configured as a service that always starts on the computer and waits for a request from the application 300.
(2) The function of the cache manager 200 is configured as a function group such as a class library, and this is incorporated into the application 300 to give the application 300 the same function.

Embodiment 10 FIG.
In the above first to ninth embodiments, it has been described that “Read Committed” is realized as the isolation level of the object cache. However, other isolation levels can also be realized by appropriately setting a flag. It is.

In the above first to ninth embodiments, the acquisition and change of the object via the cache manager 200 as well as the cache area 100 have been described as the method for constructing the object cache.
This is because the object cache is not used only for construction, but the stored object must be acquired or changed.
That is, the narrowly-defined object cache according to the present invention refers to the cache area 100, but if the object cache according to the present invention is understood in a broader sense, it can be said that it refers to the whole of the cache area 100 and the cache manager 200. is there.

2 is a configuration diagram of an object cache according to Embodiment 1. FIG. This is an image for storing an object in the cache area 100. The procedure when the application 300 deposits a new object A in the cache area 100 will be described. A procedure for accessing an object stored in the cache area 100 will be described. A procedure for reflecting changes made by the application 300 to the clone of the referenced object B in the cache area 100 and confirming the changes will be described. A state in which a new entity C is associated with an existing entity A with a relationship B is represented by a relationship model. It shows how the application 300 acquires the referenced object A stored in the cache area 100. The application 300 shows a state in which an object C to be newly added and a related object B representing a relation are generated. It shows how each object acquired and generated by the application 300 is reflected in the cache area 100. It shows how changes made to the cache area 100 are confirmed. This shows the first step of deleting the object C in the cache area 100. The step of reflecting the clone of the referenced object B in the cache area 100 is shown. The step of deleting the reference information from the referenced object A / C toward the reference object B is shown. This shows how the objects to be deleted are sequentially deleted from the cache area 100. This shows how the objects to be deleted are sequentially deleted from the cache area 100. This shows how the objects to be deleted are sequentially deleted from the cache area 100. The lock range of the cache area 100 in the fifth embodiment will be described. A principle procedure for acquiring a plurality of objects from the cache area 100 will be described. In the sixth embodiment, a procedure for acquiring a plurality of objects from the cache area 100 will be described. A difference between the conventional cache and the object cache according to the sixth embodiment regarding the memory use will be compared and described.

Explanation of symbols

  100 cache area, 110 reference object area, 120 referenced object area, 200 cache manager, 300 application.

Claims (15)

A method of building an object cache on a computer memory,
Securing a cache area on the memory;
Storing a cache object in the cache area;
Receiving an access request for the stored cache target object;
Have
When storing the cache target object in the cache area,
The cached object
A referenced object that represents the contents of the cached object itself,
A reference object that holds reference information for the referenced object;
Divided into two and stored in the cache area,
When an access request for the stored referenced object is received,
Returns a reference to the referenced object via the reference object;
A method for constructing an object cache, characterized in that the referenced object is indirectly accessed using the reference. When receiving an access request for the referenced object stored in the cache area,
A clone of the referenced object,
Create a reference object that holds the reference information for the clone,
Returns a reference to the clone via its reference object,
The object cache construction method according to claim 1, wherein the clone is accessed using the reference. When receiving an access request for a referenced object stored in the cache area and generating a clone of the referenced object,
Reference information to other objects referenced by the referenced object
The object cache construction method according to claim 2, wherein the clone is held as information for specifying a reference destination object referred to by the clone. Receiving a request to reflect changes made to the clone in the cache area;
A change confirmation step for reflecting the change in the cache area based on the request;
Have
In the change confirmation step,
The reference information of the reference object that holds the reference information for the referenced object that is the source of the clone related to the change,
By rewriting the reference information for the clone to be changed,
The object cache construction method according to claim 2 or 3, wherein a change made to the clone is reflected in the cache area. In the case where the referenced object is stored in the cache area,
Receiving a request to store a new cache target object associated with the referenced object in the cache area;
An association addition confirmation step for storing a new cache target object in the cache area based on the request and associating the new cache target object with the previously-referenced object;
Have
In the association addition confirmation step,
Generate a clone of the referenced object stored in the cache area first,
The object cache construction method according to any one of claims 2 to 4, wherein the clone and a new cache target object are associated with each other and stored in the cache area. In the association addition confirmation step,
Generating a related object that retains association information between the referenced object previously stored in the cache area and the new cache target object;
6. The object cache construction method according to claim 5, wherein a new cache target object and the related object are stored in the cache area. In the association addition confirmation step,
The referenced object stored in the cache area first holds the reference information for the reference object corresponding to the related object, and
The object cache construction method according to claim 6, further comprising: causing a new cache target object to hold reference information directed to a reference object corresponding to the related object. In the association addition confirmation step,
In the related object stored in the cache area,
While holding the reference information for the reference object corresponding to the referenced object previously stored in the cache area,
The object cache construction method according to claim 6 or 7, wherein reference information for a reference object corresponding to a new cache target object is held. In the association addition confirmation step,
Flag information indicating that the process is being performed is held in a reference object corresponding to the referenced object previously stored in the cache area,
The object cache construction method according to any one of claims 5 to 8, wherein the flag information is returned when an access request for the reference object is received. In the case where the referenced object and the related object are stored in the cache area,
Receiving a request to delete the referenced object associated by the related object from the cache area;
A deletion confirmation step of deleting the referenced object from the cache area based on the request;
Have
In the deletion confirmation step,
Creating a clone of the related object;
Create a reference object that holds the reference information for the clone,
Via its reference object
A referenced object associated with the associated object;
The object cache construction method according to claim 6, wherein the association with the related object is deleted. In the deletion confirmation step,
Rewriting the reference information of the reference object that holds the reference information for the related object, with reference information for the clone of the related object,
Held by the referenced object associated by the related object,
By deleting the association towards the reference object corresponding to the related object,
The object cache construction method according to claim 10, wherein reference information of an object associated with the related object is deleted. In the deletion confirmation step,
Flag information indicating that the processing is being performed is held in a reference object corresponding to the related object,
The object cache construction method according to claim 10 or 11, wherein the flag information is returned when an access request for the reference object is received. When confirming changes to be made to each object stored in the cache area,
The object cache construction method according to any one of claims 4 to 12, wherein the object refers to or changes to surrounding objects that refer to the object are prohibited. Receiving a request to collectively acquire a plurality of referenced objects stored in the cache area;
Upon receiving that request,
Receives agent objects that execute batch acquisition,
Without creating a clone of the referenced object,
In that agent object,
The object cache construction according to any one of claims 1 to 13, wherein attribute values held by a plurality of referenced objects stored in the cache area are directly obtained using the reference information. Method. An object cache construction program that causes the computer to execute the object cache construction method according to any one of claims 1 to 14.

Images