SIP server architecture for improving latency during message processing

• US 7,954,005 B2
• Filed: 02/02/2010
• Issued: 05/31/2011
• Est. Priority Date: 10/10/2006
• Status: Active Grant

• Current Assignee: Oracle International Corporation (Oracle Corporation)
• Original Assignee: Oracle International Corporation (Oracle Corporation)
• Inventors: Beatty, John, Connelly, David, Cheenath, Manoj, Cosmadopoulos, Ioannis, Langen, Anno R., Kramer, Reto, Khan, Rao Nasir
• Primary Examiner(s): Iqbal; Nadeem
• Application Number:
  US12/698,852
• Publication Number:
  US 20100205263A1
• Time in Patent Office: 483 Days
• Field of Search: 714/4, 714/6, 714/8, 714/10, 714/11, 714 15- 18, 714/20, 714/21, 714/26, 714/31, 714 37- 39, 714/47
• US Class Current: 714/15
• CPC Class Codes: G06F 11/1425 by reconfiguration of node membership
• CPC Class Codes: G06F 11/2028 eliminating a faulty processor or activating a spare
• CPC Class Codes: G06F 11/2094 Redundant storage or storage space G06F11/2056 takes precedence
• CPC Class Codes: H04L 65/1045 Proxies, e.g. for session initiation protocol [SIP]
• CPC Class Codes: H04L 65/1104 Session initiation protocol [SIP]
• 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 69/40 for recovering from a failure of a protocol instance or entity, e.g. service redundancy protocols, protocol state redundancy or protocol service redirection management of faults, events, alarms or notifications in data switching networks H04L41/06

Abstract

Systems and methods are provided for improving latency during message processing in a network environment via the use of SIP server architecture. The SIP server can be comprised of an engine tier and a state tier distributed on a cluster network. The engine tier can send and receive messages and execute various processes. The state tier can maintain in-memory state data associated with various SIP sessions. The state tier can store various long lived data objects and the engine tier can contain short lived data objects. The state data can be maintained in partitions comprised of state replicas. When processing messages, the engine can pull state data objects from the state tier, use the objects and push them back to the state tier after processing is complete. If one state replica is unavailable, such as during garbage collection, the engine can retrieve the objects from another replica in the partition.

Claims

1. A system for improving latency during message processing in a network environment, said system comprising:

an engine tier distributed on a cluster network of computing devices, wherein the engine tier maintains short lived data objects that are local in thread scope, wherein the short lived data objects in the engine tier are garbage collected during thread processing on the engine tier; and

a state tier distributed on the cluster network of said computing devices, wherein the state tier maintains long lived data objects that are global in thread scope, wherein the long lived data objects in the state tier are garbage collected by halting all thread processing in the state tier for a period of time;

wherein the engine tier receives a message associated with a call having call state and upon receiving the message, the engine tier

locks the call state stored in the long lived data objects in the state tier,

retrieves the call state from the long lived data objects in the state tier and stores the call state locally in the short lived data objects,

processes said message using the call state stored in the short lived data objects locally in the engine tier,

updates the call state to the long lived data objects in the state tier with changes caused by the processing of said message, and

unlocks said call state in the long lived data objects in the state tier once the call state has been updated;

whereby the halting of all thread processing caused by garbage collecting the long lived objects in the state tier is separated from message processing in the engine tier.

2. The system of claim 1, wherein the short lived data objects are removed from the engine tier after updating the call state in the long lived data objects in the state tier.

3. The system of claim 1, further comprising:

a partition located in the state tier, the partition including one or more state replicas for storing duplicate state thereon.

4. The system of claim 3, further comprising:

an engine node located in the engine tier, the engine node in communication with the partition such that the engine node can retrieve the set of long lived objects from any state replica within the partition.

5. The system of claim 4, wherein the engine node attempts to retrieve the set of long lived objects from a first state replica, determines that the first state replica is busy performing garbage collection and retrieves the set of long lived objects from a second state replica.

6. The system of claim 1, wherein the engine tier continues to process messages while simultaneously garbage collecting the short lived data objects and wherein the state tier stops processing requests in order to garbage collect the long lived data objects.

7. The system of claim 1, wherein the message is a session initiated protocol (SIP) message originated by at least one of a phone, a wireless device and an application.

8. The system of claim 1, wherein the state tier maintains session initiation protocol (SIP) state data including a set of timer objects for retransmitting messages to SIP clients.

9. The system of claim 1, further comprising:

a load balancer coupled to the cluster network, wherein the load balancer receives the message and distributes the message to an engine for processing.

10. The system of claim 1, wherein the short lived data objects are localized to a thread such that a garbage collector is capable of removing the short lived data objects without interfering with execution of other threads.

11. A method for improving latency during message processing in a network environment, said method comprising:

maintaining an engine tier on a network cluster of computing devices, wherein the engine tier processes incoming messages and stores short lived objects that are local in thread scope, wherein the short lived objects in the engine tier are garbage collected during thread processing on the engine tier;

maintaining a state tier on the network cluster of said computing devices, wherein the state tier stores long lived objects that are used in processing the incoming messages, said long lived objects being global in thread scope, wherein the long lived objects in the state tier are garbage collected by halting all thread processing in the state tier for a period of time;

receiving, by the engine tier, an incoming message associated with a call having call state, wherein upon receiving the incoming message, the engine tier

locks the call state stored in the long lived objects in the state tier,

retrieves the call state from the long lived objects in the state tier and stores the call state locally in the short lived objects,

processes said incoming message using the call state stored in the short lived objects locally in the engine tier,

updates the call state to the long lived objects in the state tier with changes caused by the processing of said incoming message, and

unlocks said call state in the long lived objects in the state tier once the call state has been updated;

whereby the halting of all thread processing caused by garbage collecting the long lived objects in the state tier is separated from message processing in the engine tier.

12. The method of claim 11, further comprising:

removing the short lived objects from the engine tier after the call state has been updated in the long lived data objects in the state tier.

13. The method of claim 11, wherein the long lived objects in the state tier are maintained in partitions, each partition including one or more state replicas for storing duplicate state data thereon.

14. The method of claim 13, wherein engines in the engine tier communicate with the partitions such that each engine can access the long lived objects from any state replica in the partition.

15. The method of claim 14, further comprising:

attempting to retrieve the long lived objects from a first state replica in the partition;

determining that the first state replica is busy performing garbage collection; and

retrieving the long lived objects from a second state replica in the partition.

16. The method of claim 11, wherein the engine tier continues to process messages while simultaneously garbage collecting the short lived objects and wherein the state tier stops processing requests in order to garbage collect the long lived objects.

17. The method of claim 11, wherein the message is a session initiated protocol (SIP) message originated by at least one of a phone, a wireless device and an application.

18. The method of claim 11, wherein the state tier maintains session initiation protocol (SIP) state data for specifying at least one of caller identification, callee identification, type of application, type of message and when to fire a timer object.

19. The method of claim 11, wherein receiving an incoming message further comprises:

receiving the message by a load balancer coupled to the cluster network and distributing it to an engine in the engine tier as determined by the load balancer.

20. A computer-readable storage medium having a set of instructions stored thereon, said instructions when executed by one or more processors, causing the one or more processors to carry out the steps of:

maintaining an engine tier on a network cluster of computing devices, wherein the engine tier processes incoming messages and stores short lived objects that are local in thread scope, wherein the short lived objects in the engine tier are garbage collected during thread processing on the engine tier;

maintaining a state tier on the network cluster of said computing devices, wherein the state tier stores long lived objects that are used in processing the incoming messages, said long lived objects being global in thread scope, wherein the long lived objects in the state tier are garbage collected by halting all thread processing in the state tier for a period of time;

receiving, by the engine tier, an incoming message associated with a call having call state, wherein upon receiving the incoming message, the engine tier

locks the call state stored in the long lived objects in the state tier,

retrieves the call state from the long lived objects in the state tier and stores the call state locally in the short lived objects,

processes said incoming message using the call state stored in the short lived objects locally in the engine tier,

updates the call state to the long lived objects in the state tier with changes caused by the processing of said incoming message, and

unlocks said call state in the long lived objects in the state tier once the call state has been updated;

whereby the halting of all thread processing caused by garbage collecting the long lived objects in the state tier is separated from message processing in the engine tier.