SIP SERVER ARCHITECTURE FOR IMPROVING LATENCY DURING MESSAGE PROCESSING

• US 20100205263A1
• Filed: 02/02/2010
• Published: 08/12/2010
• Est. Priority Date: 10/10/2006
• Status: Active Grant

• Current Assignee: Oracle International Corporation (Oracle Corporation)
• Original Assignee: BEA Systems Incorporated (Oracle Corporation)
• Inventors: Langen, Anno R., Kramer, Reto, Beatty, John, Connelly, David, Cheenath, Manoj, Cosmadopoulos, Ioannis, Khan, Rao Nasir
• Granted Patent: US 7,954,005 B2
• Time in Patent Office: Days
• US Class Current: 709/206
• 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, 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, 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 and processes the message by retrieving a subset of long lived objects from the state tier and employing the subset of long lived data objects as short lived data objects on the engine tier, and wherein once the message is finished processing in the engine tier, the short lived data objects are pushed back to the state tier; and

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 pushing the short lived data objects back to 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, 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 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 an incoming message;

retrieving a subset of the long lived objects from the state tier into the engine tier and employing the subset of long lived objects as short lived objects in the engine tier;

processing the incoming message by an engine in the engine tier; and

pushing the one or more long lived objects from the engine tier back to the state tier once the message is finished processing in the engine tier, 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 one or more long lived objects employed as the short lived objects from the engine tier after they have been pushed back onto 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, 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 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 an incoming message;

retrieving a subset of the long lived objects from the state tier into the engine tier and employing the subset of long lived objects as short lived objects in the engine tier;

processing the incoming message by an engine in the engine tier; and

pushing the one or more long lived objects from the engine tier back to the state tier once the message is finished processing in the engine tier, 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.