1. An apparatus comprising:
at least one processor;
a memory coupled to the at least one processor;
an object persistence mechanism residing in memory, the object persistence mechanism including a reference object and a persistent storage object, with the reference object having a persistence flag to indicate that the reference object is a reference object and a pointer to the persistent storage object.
2. The apparatus of claim 1 wherein the storage object includes instance data for an object that is to be persistent.
3. The apparatus of claim 1 wherein the pointer to the storage object comprises a 64 bit address.
4. The apparatus of claim 1 wherein the storage object comprises an AS400 system object.
5. The apparatus of claim 1 wherein the reference object appears as a normal object to other objects in memory.
6. The apparatus of claim 1 further comprising a plurality of transient objects residing in memory, wherein each of the plurality of transient objects includes a persistence flag indicating that the plurality of transient objects are not persistent.
7. The apparatus of claim 1 wherein said reference object resides in a virtual machine.
8. The apparatus of claim 7 wherein the virtual machine comprises a Java virtual machine.
9. The apparatus of claim 7 wherein the virtual machine includes a getfield bytecode, wherein said getfield bytecode retrieves a specified field from a specified object, wherein said getfield bytecode checks the specified object for a persistence flag before retrieving the specified field and wherein the getfield bytecode retrieves the specified field from an associated storage object when said persistence flag indicates that the specified object is a persistent object.
10. The apparatus of claim 9 wherein the getfield bytecodes checks to determine if the specified field includes a persistent pointer to a storage object, and wherein the getfield bytecode retrieves a pointer to a corresponding reference object when said specified field includes a persistent pointer to a storage object.
11. The apparatus of claim 7 wherein the virtual machine includes a putfield bytecode, wherein said putfield bytecode stores data into a specified field in a specified object, wherein said putfield bytecode checks the specified object for a persistence flag before putting the data into the specified field and wherein the putfield bytecode puts the data into the specified field of an associated storage object when said persistence flag indicates that the specified object is a persistent object.
12. The apparatus of claim 1 wherein the persistence mechanism further includes a persistent class registry, said persistent class registry tracking classes for which persistent objects can be made.
13. The apparatus of claim 1 wherein the persistence mechanism further includes a reference object table, said reference object table including a list of all reference objects created in said memory searchable by persistent address of associated storage object.
14. A method for providing object persistence comprising the steps of:
a) providing a storage object persistently stored in a backing storage, the storage object storing instance data for a first object;
b) providing a reference object corresponding to the storage object, the reference object including a persistence flag indicating the reference object is a reference object and a pointer to the corresponding storage object in backing storage; and
c) performing a field access on the first object by calling a method on the reference object, retrieving the pointer to the corresponding storage object in backing storage and performing the field access on the corresponding storage object.
15. The method of claim 14 wherein the step of performing the field access comprises checking the persistence flag on the reference object to determine that the reference object is a reference and not a regular transient object.
16. The method of claim 14 wherein the step of performing a field access comprises performing a getfield access.
17. The method of claim 14 wherein the step of performing a field access comprises performing a putfield access.
18. The method of claim 14 wherein address stored in the storage object comprise persistent single level storage addresses.
19. The method of claim 14 wherein the reference object resides in a virtual machine.
20. The method of claim 19 wherein the virtual machine is a Java virtual machine.
21. The method of claim 14 wherein the storage object comprises an AS400 system object.
22. The method of claim 14 wherein the step of performing a field access comprises performing a getfield access, and wherein the step of performing the field access on the storage object comprises checking to determine if the accessed field includes a persistent pointer to a second Storage object, and further comprising the steps of checking if a second reference object corresponding to the second storage object exists and creating a second reference object if it does not exist and passing an address to the second reference object.
23. A program product comprising:
(A) an object persistence mechanism, the object persistence mechanism including a reference object and a persistent storage object, with the reference object having a persistence flag to indicate that the reference object is a reference object and a pointer to the persistent storage object; and
(B) signal bearing media bearing the object persistence mechanism.
24. The program product of claim 23 wherein the signal bearing media comprises recordable media.
25. The program product of claim 23 wherein the signal bearing media comprises transmission media.
26. The program product of claim 23 wherein the storage object includes instance data for an object that is to be persistent.
27. The program product of claim 23 wherein the pointer to the storage object comprises a 64 bit address.
28. The program product of claim 23 wherein the storage object comprises an AS400 system object.
29. The program product of claim 23 wherein the reference object appears as a normal object to other objects.
30. The program product of claim 23 further comprising a plurality of transient objects, wherein each of the plurality of transient objects includes a persistence flag indicating that the plurality of transient objects are not persistent.
31. The program product of claim 23 wherein said reference object resides in a virtual machine.
32. The program product of claim 31 wherein the virtual machine comprises a Java virtual machine.
33. The program product of claim 31 wherein the virtual machine includes a getfield bytecode, wherein said getfield bytecode retrieves a specified field from a specified object, wherein said getfield bytecode checks the specified object for a persistence flag before retrieving the specified field and wherein the getfield bytecode retrieves the specified field from an associated storage object when said persistence flag indicates that the specified object is a persistent object.
34. The program product of claim 33 wherein the getfield bytecodes checks to determine if the specified field includes a persistent pointer to a storage object, and wherein the getfield bytecode retrieves a pointer to a corresponding reference object when said specified field includes a persistent pointer to a storage object.
35. The program product of claim 31 wherein the virtual machine includes a putfield bytecode, wherein said putfield bytecode stores data into a specified field in a specified object, wherein said putfield bytecode checks the specified object for a persistence flag before putting the data into the specified field and wherein the putfield bytecode puts the data into the specified field of an associated storage object when said persistence flag indicates that the specified object is a persistent object.
36. The program product of claim 31 wherein the persistence mechanism further includes a persistent class registry, said persistent class registry tracking classes for which persistent objects can be made
37. The program product of claim 3 I wherein the persistence mechanism further includes a reference object table, said reference object table including a list of all reference objects created in said memory searchable by persistent address of associated storage object.
38. An apparatus comprising:
a) at least one processor;
b) a memory coupled to the at least one processor;
c) a virtual machine residing in the memory, the virtual machine including a plurality of objects and a plurality of bytecodes to perform operations on said objects residing in said virtual machine;
d) an object persistence mechanism, the object persistence mechanism including:
i) a storage object persistently stored in a backing storage, the storage object storing instance data for a persistent object;
ii) a reference object residing in the virtual machine, the reference object including a persistence flag and a pointer to the storage object in the backing storage, wherein the reference object operates as other of the plurality of objects to the view of the plurality of objects in the virtual machine.
39. The apparatus of claim 38 wherein the plurality of bytecodes includes a getfield bytecode, wherein said getfield bytecode retrieves a specified field from a specified object and wherein said getfield bytecode checks the specified object for a persistence flag before retrieving the specified field and retrieves the specified field from an associated storage object when said persistence flag indicates that the specified object is a persistent object.
40. The apparatus of claim 39 wherein the getfield bytecodes checks to determine if the specified field includes a persistent pointer to another storage object, and wherein the getfield bytecode retrieves a pointer to a corresponding reference object when said specified field includes a persistent pointer to the another storage object.
41. The apparatus of claim 38 wherein the plurality of bytecodes includes a putfield bytecode, wherein said putfield bytecode stores data into a specified field in a specified object, wherein said putfield bytecode checks the specified object for a persistence flag before putting the data into the specified field and puts the data into the specified field of an associated storage object when said persistence flag indicates that the specified object is a persistent object.
42. The apparatus of claim 38 wherein the plurality of bytecodes include a plurality of load bytecodes for retrieving data from a specified array object and wherein said load bytecodes check the specified array object for a persistence flag before retrieving the specified field and wherein the load bytecodes retrieve the specified field from an associated storage object when said persistence flag indicates that the specified array object is a persistent object.
43. The apparatus of claim 38 wherein the plurality of bytecodes includes a plurality of store bytecodes for storing data into a specified array object and wherein said store bytecodes check the specified array object for a persistence flag before storing the data into the specified field and wherein the store bytecodes store the data into the specified field in an associated storage object when said persistence flag indicates that the specified array object is a persistent object.
44. The apparatus of claim 38 wherein the persistence mechanism further comprises a persistent class registry, said persistent class registry tracking classes for which persistent objects can be made.
45. The apparatus of claim 38 wherein the persistence mechanism further includes a reference object table, said reference object table including a list of all reference objects created in said memory searchable by persistent address of associated storage object.
46. The apparatus of claim 38 wherein the virtual machine comprises a Java virtual machine.
47. The apparatus of claim 38 wherein the persistent storage object comprises an AS400 system object.
48. The apparatus of claim 38 wherein the plurality of objects in the virtual machine comprises a plurality of transient objects, and wherein each of said plurality of transient objects includes a persistence flag indicating the transient object is not persistent.
49. The apparatus of claim 48 wherein the persistence flag in the plurality of transient objects comprises a flag in the header of the encapsulating object corresponding to the transient object and wherein the persistence flag in the reference object comprises a flag in the header of the encapsulating object corresponding to the reference object.
50. The apparatus of claim 38 wherein address pointers stored in the storage object comprises single level storage address pointers.
51. A method for providing object persistence comprising the steps of:
a) providing a plurality of transient objects in a virtual machine, the plurality of reference objects each including a persistence flag indicating the plurality of transient objects are not reference objects;
b) providing a storage object persistently stored in a backing storage, the storage object storing instance data for an persistent object;
c) providing a reference object corresponding to the storage object, the reference object residing in the virtual machine and including a persistence flag indicating the reference object is a reference object, the reference object including a pointer to the corresponding storage object in backing storage; and
d) performing a field access on an first object, wherein the steps of performing a field access on the first object comprises the steps of:
i) checking the persistence flag of the first object to determine if the first object is a reference object;
ii) performing the field access on the first object if the first object is not a reference object;
iii) retrieving the pointer to the corresponding storage object in backing storage and performing the field access on the storage object in backing storage if the first object is a reference object.
52. The method of claim 51 wherein the field access is a getfield access.
53. The method of claim 51 wherein the field access is a putfield access.
54. The method of claim 51 wherein the virtual machine is a Java virtual machine.
55. The method of claim 51 wherein the persistence flag comprises a flag in a header of an encapsulating object.
56. The method of claim 55 wherein the encapsulating object comprises a C object.
57. The method of claim 51 wherein the storage object comprises an AS400 system object.
58. The method of claim 51 wherein the step of performing a field access comprises performing a getfield access, and wherein the step of performing the field access on the storage object comprises checking to determine if the accessed field includes a persistent pointer to a second storage object, and further comprising the steps of checking if a second reference object corresponding to the second storage object exists and creating a second reference object if it does not exist and passing an address to the second reference object.
59. The method of claim 51 wherein addresses stored in the storage object comprises persistent single level store addresses.
60. A program product comprising:
(A) virtual machine residing in the memory, the virtual machine including a plurality of objects and a plurality of bytecodes to perform operations on said objects residing in said virtual machine;
(B) an object persistence mechanism, the object persistence mechanism including:
i) a storage object persistently stored in a backing storage, the storage object storing instance data for a persistent object;
ii) a reference object residing in the virtual machine, the reference object including a persistence flag and a pointer to the storage object in the backing storage, wherein the reference object operates as other of the plurality of objects to the view of the plurality of objects in the virtual machine; and
(C) signal bearing media bearing said virtual machine and said object persistence mechanism.
61. The program product of claim 60 wherein the signal bearing media comprises recordable media.
62. The program product of claim 60 wherein the signal bearing media comprises transmission media.
63. The program product of claim 60 wherein the plurality of bytecodes includes a getfield bytecode, wherein said getfield bytecode retrieves a specified field from a specified object and wherein said getfield bytecode checks the specified object for a persistence flag before retrieving the specified field and retrieves the specified field from an associated storage object when said persistence flag indicates that the specified object is a persistent object.
64. The program product of claim 63 wherein the getfield bytecodes checks to determine if the specified field includes a persistent pointer to another storage object, and wherein the getfield bytecode retrieves a pointer to a corresponding reference object when said specified field includes a persistent pointer to the another storage object.
65. The program product of claim 60 wherein the plurality of bytecodes includes a putfield bytecode, wherein said putfield bytecode stores data into a specified field in a specified object, wherein said putfield bytecode checks the specified object for a persistence flag before putting the data into the specified field and puts the data into the specified field of an associated storage object when said persistence flag indicates that the specified object is a persistent object.
66. The program product of claim 60 wherein the plurality of bytecodes include a plurality of load bytecodes for retrieving data from a specified array object and wherein said load bytecodes check the specified array object for a persistence flag before retrieving the specified field and wherein the load bytecodes retrieve the specified field from an associated storage object when said persistence flag indicates that the specified array object is a persistent object.
67. The program product of claim 60 wherein the plurality of bytecodes includes a plurality of store bytecodes for storing data into a specified array object and wherein said store bytecodes check the specified array object for a persistence flag before storing the data into the specified field and wherein the store bytecodes store the data into the specified field in an associated storage object when said persistence flag indicates that the specified array object is a persistent object.
68. The program product of claim 60 wherein the persistence mechanism further comprises a persistent class registry, said persistent class registry tracking classes for which persistent objects can be made.
69. The program product of claim 60 wherein the persistence mechanism further includes a reference object table, said reference object table including a list of all reference objects created in said memory searchable by persistent address of associated storage object.
70. The program product of claim 60 wherein the virtual machine comprises a Java virtual machine.
71. The program product of claim 60 wherein the persistent storage object comprises an AS400 system object.
72. The program product of claim 60 wherein the plurality of objects in the virtual machine comprises a plurality of transient objects, and wherein each of said plurality of transient objects includes a persistence flag indicating the transient object is not persistent.
73. The program product of claim 72 wherein the persistence flag in the plurality of transient objects comprises a flag in the header of the encapsulating object corresponding to the transient object and wherein the persistence flag in the reference object comprises a flag in the header of the encapsulating object corresponding to the reference object.
74. The program product of claim 60 wherein address pointers stored in the storage object comprises single level storage address pointers.
The claims below are in addition to those above.
All refrences to claim(s) which appear below refer to the numbering after this setence.
What is claimed is:
1. An apparatus comprising:
a cache storing a plurality of entries, each of the plurality of entries containing an entry type indicating if the entry is one of a normal entry and a directory entry; and
a controller coupled to the cache to process an access request for a memory block using the plurality of entries, the access request coming from a processor in a non uniform memory architecture (NUMA) system.
2. The apparatus of claim 1 wherein the normal entry contains normal cache data.
3. The apparatus of claim 1 wherein the directory entry contains a state of the memory block and an identifier identifying at least an owner node in the NUMA system having copy of the memory block.
4. The apparatus of claim 3 wherein the access request includes at least an access tag and an index.
5. The apparatus of claim 4 wherein the controller comprises:
a cache controller coupled to the cache and a memory controller to control the cache; and
a node controller coupled to the cache controller to process a node access relating to a remote node.
6. The apparatus of claim 5 wherein the cache controller comprises:
a retrieving circuit to retrieves the entry based on the index;
a type detector to detect the entry type;
a tag matching circuit to match an entry tag with the access tag; and
a node controller interface to provide directory information retrieved from the cache to the node controller.
7. The apparatus of claim 5 wherein the node controller comprises:
a cache controller interface to provide the node access from the remote node to the cache controller;
a directory tag matching circuit to match directory tags from the directory information received from the cache controller with the access tag;
a directory allocator to allocate a directory entry in the cache; and
a directory updater to update the directory entry in the cache.
8. The apparatus of claim 7 wherein the node controller further comprises:
a remote node interface circuit to exchange remote information with the remote node;
a block transfer circuit coupled to the memory controller to transfer a memory block from a memory to the cache if the access request results in a miss; and
a node coherence logic circuit to maintain cache coherency according to a node coherence protocol.
9. The apparatus of claim 7 wherein the node controller further comprises:
a directory entry cache to store frequently accessed directory information.
10. The apparatus of claim 8 wherein the remote node interface circuit comprises:
a request forwarder to forward the access request to the owner node having the memory block; and
a data block receiver to receive the memory block sent from the owner node.
11. A method comprising:
storing a plurality of entries in a cache, each of the plurality of entries containing an entry type indicating if the entry is one of a normal entry and a directory entry; and
processing an access request for a memory block using the plurality of entries by a controller, the access request coming from a processor in a non uniform memory architecture (NUMA) system.
12. The method of claim 11 wherein the normal entry contains normal cache data.
13. The method of claim 11 wherein the directory entry contains a state of the memory block and an identifier identifying at least an owner node in the NUMA system having copy of the memory block.
14. The method of claim 13 wherein the access request includes at least an access tag and an index.
15. The method of claim 14 wherein processing the access request comprises:
controlling the cache by a cache controller coupled to a memory controller; and
processing a node access relating to a remote node by a node controller.
16. The method of claim 15 wherein controlling the cache comprises:
retrieving the entry based on the index;
detecting the entry type;
matching an entry tag with the access tag; and
providing directory information retrieved from the cache to the node controller.
17. The method of claim 15 wherein processing the node access comprises:
providing the node access from the remote node to the cache controller;
matching directory tags from the directory information received from the cache controller with the access tag;
allocating a directory entry in the cache; and
updating the directory entry in the cache.
18. The method of claim 17 wherein processing the node access further comprises:
exchanging remote information with the remote node;
transferring a memory block from a memory to the cache if the access request results in a miss; and
maintaining cache coherency according to a node coherence protocol.
19. The method of claim 17 wherein processing the node access further comprises:
storing frequently accessed directory information in a directory entry cache.
20. The method of claim 18 wherein exchanging remote information comprises:
forwarding the access request to the owner node having the memory block; and
receiving the memory block sent from the owner node.
21. A non uniform memory architecture (NUMA) system comprising:
an owner node having copy of a memory block; and
a home node coupled to the requesting node and the owner node to process an access request for the memory block from a processor, the home node having a cache subsystem, the cache subsystem comprising:
a cache storing a plurality of entries, each of the plurality of entries containing an entry type indicating if the entry is one of a normal entry and a directory entry, and
a controller coupled to the cache to process the access request for a memory block using the plurality of entries.
22. The system of claim 21 wherein the normal entry contains normal cache data.
23. The system of claim 21 wherein the directory entry contains a state of the memory block and an identifier identifying at least an owner node in the NUMA system having copy of the memory block.
24. The system of claim 23 wherein the access request includes at least an access tag and an index.
25. The system of claim 24 wherein the controller comprises:
a cache controller coupled to the cache and a memory controller to control the cache; and
a node controller coupled to the cache controller to process a node access relating to a remote node.
26. The system of claim 25 wherein the cache controller comprises:
a retrieving circuit to retrieves the entry based on the index;
a type detector to detect the entry type;
a tag matching circuit to match an entry tag with the access tag; and
a node controller interface to provide directory information retrieved from the cache to the node controller.
27. The system of claim 25 wherein the node controller comprises:
a cache controller interface to provide the node access from the remote node to the cache controller;
a directory tag matching circuit to match directory tags from the directory information received from the cache controller with the access tag;
a directory allocator to allocate a directory entry in the cache; and
a directory updater to update the directory entry in the cache.
28. The system of claim 27 wherein the node controller further comprises:
a remote node interface circuit to exchange remote information with the remote node;
a block transfer circuit coupled to the memory controller to transfer a memory block from a memory to the cache if the access request results in a miss; and
a node coherence logic circuit to maintain cache coherency according to a node coherence protocol.
29. The system of claim 27 wherein the node controller further comprises:
a directory entry cache to store frequently accessed directory information.
30. The system of claim 28 wherein the remote node interface circuit comprises:
a request forwarder to forward the access request to the owner node having the memory block; and
a data block receiver to receive the memory block sent from the owner node.