Cluster caching with concurrency checking

• US 20060123066A1
• Filed: 01/25/2006
• Published: 06/08/2006
• Est. Priority Date: 08/30/2001
• Status: Active Grant

• Current Assignee: Oracle International Corporation (Oracle Corporation)
• Original Assignee: BEA Systems Incorporated (Oracle Corporation)
• Inventors: Messinger, Adam, Jacobs, Dean Bernard, Woollen, Rob, White, Seth
• Granted Patent: US 7,444,333 B2
• Time in Patent Office: Days
• US Class Current: 1/1
• CPC Class Codes: G06F 16/9574 of access to content, e.g. by caching
• CPC Class Codes: G06Q 20/04 Payment circuits
• CPC Class Codes: G06Q 20/389 Keeping log of transactions for guaranteeing non-repudiation of a transaction
• CPC Class Codes: G07F 19/201 Accessories of ATMs
• CPC Class Codes: H04L 67/1095 Replication or mirroring of data, e.g. scheduling or transport for data synchronisation between network nodes
• CPC Class Codes: H04L 67/288 Distributed intermediate devices, i.e. intermediate devices for interaction with other intermediate devices on the same level
• CPC Class Codes: H04L 67/5682 Policies or rules for updating, deleting or replacing the stored data
• CPC Class Codes: H04L 69/329 in the application layer [OSI layer 7]
• CPC Class Codes: Y10S 707/99938 Concurrency, e.g. lock management in shared database

Abstract

Concurrency can be maintained in cluster caching when processing an update request on network server that is storing a local copy of a data item. The request can be processed using the local copy of the data item. A predicated update request can be sent to a network database storing the data item, wherein the database can commit the update if the local copy is current with the data item. If the local copy is not current, the network server can request a new copy, process the request using the current copy, and try another predicated request. The process can continue until the update is committed to the database or aborted. Once committed, any other servers in the cluster can be notified that the data item has been updated. Those other servers can drop any local copy of the data item and can request an updated copy of the data item.

Claims

1. A computer implemented method for maintaining concurrency for a copy of a data item cached on a non-database server in a cluster of non-database servers, comprising:

receiving an update request, the update request being received by a non-database server in a cluster of non-database servers storing a local copy of a data item in local cache;

processing the request using the local copy of the data item;

sending a predicated update request to a database storing the data item, whereby the database updates the data item if the data item is current with the local copy, and whereby the database does not update the data item if the data item is not current with the local copy; and

notifying other non-database servers in the cluster that the data item in the database has been updated

2. A computer implemented method according to claim 1, further comprising:

receiving a message from the database to the non-database server indicating whether the data item has been updated.

3. A computer implemented method according to claim 1, further comprising:

reading a data item from the database and storing a local copy of the data item in local cache on the non-database server.

4. A computer implemented method according to claim 1, further comprising:

receiving an update request from a client to the non-database server.

5. A computer implemented method according to claim 1, further comprising:

checking the local copy to determine whether the update request can be processed.

6. A computer implemented method according to claim 5, further comprising:

updating the local copy on the non-database server if the data item in the database is updated.

7. A computer implemented method according to claim 1, further comprising:

sending an additional predicated update request to a cluster database containing the data item, whereby the database updates the data item if the new copy is current with the data item before the update, and whereby the database does not update the data item if the new copy is not current with the data item before the update.

8. A computer implemented method for maintaining concurrency for a copy of a data item cached on a non-database server in a cluster of non-database servers, comprising:

receiving an update request, the update request being received by a non-database server in a cluster of non-database servers storing a local copy of a data item in local cache;

processing the request using the local copy of the data item;

sending a predicated update request to a database storing the data item, whereby the database updates the data item if the data item is current with the local copy, and whereby the database does not update the data item if the data item is not current with the local copy;

requesting a current copy of the data item for the non-database server and sending another predicated update if the local copy is not current with the data item in the database, the step of requesting a current copy and sending another predicated update continuing until the database updating the data item; and

notifying other non-database servers in the cluster that the data item in the database has been updated

9. A computer implemented method according to claim 8, further comprising:

receiving a message from the database to the non-database server indicating whether the data item has been updated.

10. A computer implemented method according to claim 8, further comprising:

reading a data item from the database and storing a local copy of the data item in local cache on the non-database server.

11. A computer implemented method according to claim 8, further comprising:

receiving an update request from a client to the non-database server.

12. A computer implemented method according to claim 8, further comprising:

checking the local copy to determine whether the update request can be processed.

13. A computer implemented method for maintaining concurrency for a copy of a data item cached on a non-database server in a cluster of non-database servers, comprising:

receiving an update request, the update request being received by a non-database server in a cluster of non-database servers storing a local copy of a data item in local cache;

processing the request using the local copy of the data item;

sending a predicated update request to a database storing the data item, whereby the database updates the data item if the data item is current with the local copy, and whereby the database does not update the data item if the data item is not current with the local copy;

requesting a current copy of the data item for the non-database server and sending another predicated update if the local copy is not current with the data item in the database, the step of requesting a current copy and sending another predicated update continuing until the database updating the data item; and

notifying other non-database servers in the cluster that the data item in the database has been updated, futher comprising at least one of the additional limitations (a)-(f)

(a) multicasting an update message to the other non-database servers in the cluster of non-database servers that might be storing a local copy of the data item, as part of the notifying step;

(b) multicasting a version number for the data item to the other non-database servers in the cluster of non-database servers after the data item is updated, as part of the notifying step;

(c) contacting one of the other non-database servers in the cluster of non-database servers by a point-to-point connection to indicate that the data item has been updated, as part of the notifying step;

(d) heartbeating the version number for the data item to the other non-database servers in the cluster of non-database servers after the data item is updated, as part of the notifying step;

(e) dropping a local copy of the data item on one of the other non-database servers in the cluster of non-database servers after being notified that the data item has been updated;

(f) requesting an updated copy of the data item to one of the other non-database servers in the cluster of non-database servers after being notified that the data item has been updated.

14. The computer implemented method of claim 13, wherein the at least one limitation is limitation (a).

15. The computer implemented method of claim 13, wherein the at least one limitation is limitation (b).

16. The computer implemented method of claim 13, wherein the at least one limitation is limitation (c).

17. The computer implemented method of claim 13, wherein the at least one limitation is limitation (d).

18. The computer implemented method of claim 13, wherein the at least one limitation is limitation (e).

19. The computer implemented method of claim 13, wherein the at least one limitation is limitation (f).

20. The computer implemented method of claim 13, wherein at least two limitations of limitations (a)-(f) are done.

21. A computer implemented method for updating a data item, comprising:

receiving a request to update a data item, the request being received by a non-database server storing a local copy of the data item;

processing the request using the local copy;

verifying that the local copy is a current copy of the data item; and

updating the data item in the database in response to the request if the local copy is a current copy.

22. A computer implemented method according to claim 21, further comprising:

notifying another non-database server on the network that the data item has been updated in the database.

23. A method according to claim 21, further comprising:

storing the local copy in local cache on the non-database server.

24. A method according to claim 21, further comprising:

requesting a current copy of the data item if the local copy is not a current copy of the data item.