Engine Near Cache for Reducing Latency in a Telecommunications Environment

• US 20090019158A1
• Filed: 05/15/2007
• Published: 01/15/2009
• Est. Priority Date: 05/16/2006
• Status: Active Grant

• Current Assignee: Oracle International Corporation (Oracle Corporation)
• Original Assignee: BEA Systems Incorporated (Oracle Corporation)
• Inventors: Beatty, John D., Langen, Anno R., Cosmadopoulos, Ioannis, Khan, Rao Nasir
• Granted Patent: US 8,112,525 B2
• Time in Patent Office: Days
• US Class Current: 709/226
• CPC Class Codes: H04L 65/1104 Session initiation protocol [SIP]
• CPC Class Codes: H04L 67/1001 for accessing one among a plurality of replicated servers
• 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/568 Storing data temporarily at an intermediate stage, e.g. caching

Abstract

The SIP server can be comprised of an engine tier and a state tier distributed on a cluster network environment. The engine tier can send, receive and process various messages. The state tier can maintain in-memory state data associated with various SIP sessions. A near cache can be residing on the engine tier in order to maintain a local copy of a portion of the state data contained in the state tier. Various engines in the engine tier can determine whether the near cache contains a current version of the state needed to process a message before retrieving the state data from the state tier. Accessing the state from the near cache can save on various latency costs such as serialization, transport and deserialization of state to and from the state tier. Furthermore, the near cache and JVM can be tuned to further improve performance of the SIP server.

Claims

1. A computer implemented method for providing a near engine cache in a network environment, comprising:

maintaining an engine tier distributed over a cluster network and adapted to process one or more messages;

maintaining a state tier distributed over the cluster network and adapted to store state data associated with the messages;

storing a local copy of a portion of the state data onto a near cache residing on the engine tier;

receiving a message;

determining whether a current version of the state data associated with the message is in the near cache;

retrieving the state data associated with the message from the state tier if no current version is stored in the near cache, otherwise accessing the state data in the near cache.

2. The method of claim 1 wherein retrieving the state from the state tier further comprises:

serializing the state data and transporting it to the engine tier; and

deserializing the state data in the engine tier.

3. The method of claim 2 wherein accessing the state data in the near cache does not require serializing and deserializing the state data.

4. The method of claim 3 further comprising:

adjusting the size of the near cache in order to achieve a balance between latency introduced by garbage collection and latency reduced by elimination of serializing and deserializing the state data.

5. The method of claim 1 wherein the state data is maintained in random access memory (RAM) on the state tier and on the near cache.

6. The method of claim 1 wherein the state data in the near cache is implemented as a bounded map of call states indexed by call ID.

7. The method of claim 1 further comprising:

providing one or more timer objects for specifying to the engine tier when to process the incoming messages wherein the timer objects are integrated with the near cache such that the state data can be accessed from the near cache by the engine tier while processing messages specified by the timer objects.

8. The method of claim 1 wherein receiving a message further comprises:

receiving the message by a load balancer; and

distributing the message to an engine node in the engine tier;

wherein the load balancer distributes all messages associated with a same call leg to the same engine node in the engine tier.

9. The method of claim 1 wherein retrieving and accessing the state data further includes locking the state data in the state tier.

10. The method of claim 1 further comprising:

saving the state data in the near cache after processing the message; and

writing the state data to the state tier.

11. A system for providing a near cache for a network environment, comprising:

an engine tier distributed on a cluster network and adapted to process messages;

a state tier distributed on the cluster network and adapted to maintain state associated with the messages such that the engine tier retrieves the state maintained in the state tier in order to process the messages; and

a near cache residing on the engine tier for storing a local copy of a portion of the state maintained in the state tier such that the engine tier can acquire the state from the near cache instead of retrieving from the state tier.

12. The system of claim 11 wherein retrieving the state from the state tier further comprises:

serializing the state data and transporting it to the engine tier; and

deserializing the state data in the engine tier.

13. The system of claim 12 wherein acquiring the state from the near cache does not require serializing and deserializing the state data.

14. The system of claim 13 wherein the size of the near cache is adjusted in order to achieve a balance between latency introduced by garbage collection and latency reduced by elimination of serializing and deserializing the state.

15. The system of claim 11 wherein the state is maintained in random access memory (RAM) on the state tier and on the near cache.

16. The system of claim 11 further comprising:

one or more timer objects for specifying to the engine tier when to process the incoming messages wherein the timer objects are integrated with the near cache such that the state can be accessed from the near cache by the engine tier while processing messages specified by the timer objects.

17. The system of claim 11 further comprising:

a load balancer that receives an incoming message and distributes the message to an engine node in the engine tier for processing wherein the load balancer distributes all messages associated with a same call leg to the same engine node in the engine tier.

18. The system of claim 11 wherein the state is locked in the state tier whenever the engine tier is using the state for message processing.

19. The system of claim 11 wherein the state is saved into the near cache after processing the message and wherein the state is written into the near cache.

20. A computer readable medium having instructions stored thereon which when executed by one or more processors cause a system to:

maintain an engine tier distributed over a cluster network and adapted to process one or more messages;

maintain a state tier distributed over the cluster network and adapted to store state data associated with the messages;

store a local copy of a portion of the state data onto a near cache residing on the engine tier;

receive a message;

determine whether a current version of the state data associated with the message is in the near cache;

retrieve the state data associated with the message from the state tier if no current version is stored in the near cache, otherwise accessing the state data in the near cache.