Transaction accelerator for client-server communication systems

• US 7,120,666 B2
• Filed: 10/30/2002
• Issued: 10/10/2006
• Est. Priority Date: 10/30/2002
• Status: Expired due to Term

• Current Assignee: Riverbed Technology, LLC (Riverbed Technology Incorporated)
• Original Assignee: Riverbed Technology Incorporated
• Inventors: McCanne, Steven, Demmer, Michael J.
• Primary Examiner(s): Pwu, Jeffrey
• Assistant Examiner(s): NGUYEN, PHUOC H
• Application Number:
  US10/285,315
• Publication Number:
  US 20040088376A1
• Time in Patent Office: 1,441 Days
• Field of Search: 709/203, 709/245, 709/246, 709/247, 709213-216, 709/55, 709/236, 341/55, 341/51, 711/1, 711/147, 711/148, 711/206, 711/209, 711/203
• US Class Current: 709/203
• 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/289 Intermediate processing functionally located close to the data consumer application, e.g. in same machine, in same home or in same sub-network
• CPC Class Codes: H04L 67/56 Provisioning of proxy services store-and-forward switching systems in data switching networks H04L12/54
• CPC Class Codes: H04L 67/5651 Reducing the amount or size of exchanged application data
• 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]

Abstract

In a network having transaction acceleration, for an accelerated transaction, a client directs a request to a client-side transaction handler that forwards the request to a server-side transaction handler, which in turn provides the request, or a representation thereof, to a server for responding to the request. The server sends the response to the server-side transaction handler, which forwards the response to the client-side transaction handler, which in turn provides the response to the client. Transactions are accelerated by the transaction handlers by storing segments of data used in the transactions in persistent segment storage accessible to the server-side transaction handler and in persistent segment storage accessible to the client-side transaction handler. When data is to be sent between the transaction handlers, the sending transaction handler compares the segments of the data to be sent with segments stored in its persistent segment storage and replaces segments of data with references to entries in its persistent segment storage that match or closely match the segments of data to be replaced. The receiving transaction store reconstructs the data sent by replacing segment references with corresponding segment data from its persistent segment storage, requesting missing segments from the sender as needed. The transaction accelerators could handle multiple clients and/or multiple servers and the segments stored in the persistent segment stores can relate to different transactions, different clients and/or different servers. Persistent segment stores can be prepopulated with segment data from other transaction accelerators.

Claims

1. In a network wherein clients initiate transactions with servers and the network carries request messages from the clients to the servers and response messages from the servers to the client and wherein at least one of the request messages and the response messages contains a payload to be transported over the network from a sender to a receiver, a method of accelerating transactions comprising:

segmenting the payload into at least one segment according to a segmentation process that is based on the payload content;

for each of the at least one segment, determining whether to send the segment data in the payload as an unreferenced segment or as a referenced segment;

for each of the referenced segments, replacing at least some of the segment data with a reference to the replaced data and storing the replaced reference data associated with its reference;

sending the payload from the sender to the receiver as an accelerated payload comprising at least one of a segment references and symbols corresponding to an unreferenced segment;

receiving the accelerated payload over the network;

identifying the zero or more segment references in the accelerated payload;

replacing the one or more segment references in the accelerated payload with segment data available to the receiver, to form a reconstructed payload;

providing the reconstructed payload to the receiver as the transported payload;

when segment data is to be stored as part of a segment reference, transforming the segment data via an invertible function of the segment data, and storing the results of this transformation;

and when this segment data is to be used in dereferencing a segment, untransforming the stored results using an inverse of the invertible function.

2. The method of claim 1, further comprising:

deploying two or more transaction accelerators in a network;

receiving the payload from a sender server or sender client at a first transaction accelerator;

sending the accelerated payload from the first transaction accelerator to a second transaction accelerator; and

sending the reconstructed payload from a second transaction accelerator to the receiving client or receiving server, such that the acceleration is transparent to the sender'"'"'s sending protocol and to the receivers'"'"' receiving protocol.

3. The method of claim 1, further comprising:

determining, at the transaction accelerator associated with the receiver, when segment data for a referenced segment is not available for payload reconstruction; and

requesting segment data from a transaction accelerator associated with the sender.

4. The method of claim 1, wherein the invertible function is one or more of a forward error correction function, an encryption function and a signature function.

5. The method of claim 1, further comprising sending at least a part of the payload as unsegmented data.

6. In a network wherein clients initiate transactions with servers and the network carries request messages from the clients to the servers and response messages from the servers to the clients and wherein at least one of the request messages and the response messages contains a payload to be transported over the network from a sender to a receiver, a transaction accelerator comprising:

a transaction transformer for transforming a payload of a message to be sent, comprising;

a) a segmenter for segmenting the payload into at least one segment, according to a segmentation process that is based on the payload content; and

b) a replacer for determining whether to represent the segment data of each of the at least one segment as an unreferenced segment or as a referenced segment;

a persistent segment store that stores segment data and segment references for referenced segments;

an inverse transaction transformer for untransforming an accelerated payload from a transaction transformer of a remote transaction accelerator, comprising;

a) a tokenizer that determines where segment references appear in the accelerator payload; and

b) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer;

a reference resolver for resolving references as needed by the dereferencer when encountering a segment reference to a segment that is not present in the persistent segment store.

7. The method of claim 6, further comprising sending at least a part of the payload as unsegmented data.

8. In a network wherein clients initiate transactions with servers and the network carries a request message from a client to a server and a response message from the server to the client and wherein at least one of the request message and the response message contains a payload to be transported over the network from a sender to a receiver, an improvement comprising:

a client-side transaction accelerator, comprising;

a) a proxy coupled to the client for receiving request messages for delivery to servers and for relaying reconstructed response messages from the servers to the client;

b) a transaction transformer for transforming a request message received from the proxy, comprising;

i) a segmenter for segmenting the request message payload into at least one segment, according to a Segmentation process that is based on the payload content; and

ii) a replacer for determining whether to represent the segment data of each of the at least one segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the request message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a response message payload into a reconstructed response message when the response message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the response message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer; and

a server-side transaction accelerator, comprising;

a) a proxy coupled to the server for receiving response messages for delivery to clients and for relaying reconstructed request messages from clients to the server;

b) a transaction transformer for transforming a response message received from the proxy, comprising;

i) a segmenter for segmenting the response message payload into at least one segment, according to a segmentation process that is based on the payload content; and

ii) a replacer for determining whether to represent the segment data of each of the at least one segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the response message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a request message payload into a reconstructed request message when the request message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the request message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer,

wherein at least one segment in either the request message payload or a response message payload is sent as a referenced segment.

9. The improvement of claim 8, further comprising:

a client-side reference resolver for resolving references as needed by the client-side dereferencer when encountering a segment reference to a segment that is not present in the client-side persistent segment store; and

a server-side reference resolver for resolving references as needed by the server-side dereferencer when encountering a segment reference to a segment that is not present in the server-side persistent segment store.

10. The improvement of claim 8, wherein one of the client-side transaction accelerator and the server-side transaction accelerator is a first transaction accelerator and the other one of the client-side transaction accelerator and the server-side transaction accelerator is a second transaction accelerator, the improvement further comprising:

means at the first transaction accelerator for anticipating segment requirements of the second transaction accelerator; and

means for conveying anticipated segments from the first transaction accelerator to the persistent segment store of the second transaction accelerator prior to the need of those anticipated segments by the dereferencer of the second transaction accelerator.

11. The improvement of claim 8, further comprising:

means, at each transaction accelerator of a set of transaction accelerators cooperating over a network, for allocating segment reference identifiers such that the segment reference identifiers are unique over the set of transaction accelerators, wherein the segment reference identifiers are selected from an effectively unbounded identifier space; and

means for compressing the segment identifiers to form compressed segment identifiers used in one or more of data storage and data transmission.

12. The method of claim 8, further comprising sending at least a part of the payload as unsegmented data.

13. In a network wherein clients initiate transactions with servers and the network carries request messages from the clients to the servers and response messages from the servers to the clients and wherein at least one of the request messages and the response messages contains a payload comprising one or more segments, segmented according to a segmentation process that is based on the payload content, wherein the payload is to be transported over the network from a sender to a receiver, a method of accelerating transactions comprising:

for each of the segments, determining whether to send the segment data in the payload as an unreferenced segment or as a referenced segment;

for each of the referenced segment replacing at least some of the segment data with a reference to the replaced data and storing the replaced reference data associated with its reference in a persistent segment store;

sending the payload from the sender to the receiver as an accelerated payload;

receiving the accelerated payload over the network;

identifying segment references, if any, in the accelerated payload;

replacing the segment references in the accelerated payload with segment data available to the receiver, to form a reconstructed payload;

providing the reconstructed payload to the receiver as the transported payload;

when segment data is to be stored as part of a segment reference, transforming the segment data via an invertible function of the segment data, and storing the results of this transformation;

and when this segment data is to be used in dereferencing a segment, untransforming the stored results using an inverse of the invertible function.

14. In a network wherein clients initiate transactions with servers and the network carries request messages from the clients to the servers and response messages from the servers to the, clients and wherein at least one of the request messages and the response messages contains a payload comprising one or more segments, segmented according to a segmentation process that is based on the payload content, wherein the payload is to be transported over the network from a sender to a receiver, a transaction accelerator comprising:

a transaction transformer for transforming a payload of a message to be sent, comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

a persistent segment store that stores segment data and segment references for referenced segments;

an inverse transaction transformer for untransforming an accelerated payload from a transaction transformer of a remote transaction accelerator, comprising;

a) a tokenizer that determines where segment references appear in the accelerator payload, and

b) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer; and

a reference resolver for resolving references as needed by the dereferencer when encountering a segment reference to a segment that is not present in the persistent segment store.

15. The transaction accelerator of claim 14, further comprising a proxy for terminating a TCP connection between a sender and a receiver at the transaction accelerator.

16. In a network wherein clients initiate transactions with servers and the network carries a request message from a client to a server and a response message from the server to the client and wherein at least one of the request message and the response message contains a payload comprising one or more segments to be transported over the network from a sender to a receiver, an improvement comprising:

a client side transaction accelerator, comprising;

a) a proxy coupled to the client for receiving request messages for delivery to servers and for relaying reconstructed response messages from the servers to the client;

b) a transaction transformer for transforming a request message received from the proxy comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the request message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a response message payload into a reconstructed response message when the response message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the response message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer; and

a server side transaction accelerator, comprising;

a) a proxy coupled to the server for receiving response messages for delivery to clients and for relaying reconstructed request messages from clients to the server;

b) a transaction transformer for transforming a response message received from the proxy comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the response message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a request message payload into a reconstructed request message when the request message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the request message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer.

17. The improvement of claim 16, further comprising:

a client side reference resolver for resolving references as needed by the client side dereferencer when encountering a segment reference to a segment that is not present in the client side persistent segment store; and

a server side reference resolver for resolving references as needed by the server side dereferencer when encountering a segment reference to a segment that is not present in the server side persistent segment store.

18. In a network wherein a client initiates connections to a server and the network carries request messages from the client to the server over the connections and the network carries response messages from the server to the client over the connections and wherein the client communicates with a first proxy over a first connection, the server communicates with a second proxy over a second connection, and the first proxy and the second proxy communicate with one another over a third connection, a method of transporting data between the client and the server comprising:

receiving payloads from the server at the second proxy over the second connection;

for each payload, identifying one or more data segments within the payload according to a segmentation process that is based on the payload content;

for each of the one or more data segments, determining whether to send segment data of the data segment in the payload as an unreferenced segment or as a referenced segment;

for each of the referenced segments, replacing at least some of the segment data with a reference to the replaced data and storing the replaced reference data associated with its reference in a persistent segment store, to form an accelerated payload;

sending the accelerated payload from the second proxy to the first proxy over the third connection;

receiving the accelerated payload over the third connection at the first proxy;

identifying segment references, if any, in the accelerated payload;

replacing the

segment references in the accelerated payload with segment data available to either the client or the first proxy, to form a reconstructed payload;

providing the reconstructed payload to the client over the first connection from the first proxy as the transported payload;

when segment data is to be stored as part of a segment reference, transforming the segment data via an invertible function of the segment data, and storing the results of this transformation; and

when this segment data is to be used in dereferencing a segment, untransforming the stored results using an inverse of the invertible function.

19. In a network wherein a client initiates connections to a server and the network carries request messages from the client to the server over the connections and the network carries response messages from the server to the client over the connections and wherein the client communicates with a first proxy over a first connection, the server communicates with a second proxy over a second connection, and the first proxy and the second proxy communicate with one another over a third connection, a client side transaction accelerator, comprising:

a) the first proxy coupled to the client for receiving request messages for delivery to servers over the first connection, for relaying reconstructed-response messages from the servers to the client over the first connection, for sending an accelerated payload to the second proxy over the third connection, and for receiving an accelerated payload from the second proxy over the third connection;

b) a transaction transformer for transforming a request message received from the first proxy comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the request message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a response message payload into a reconstructed response message when the response message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the response message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer.

20. The client side transaction accelerator of claim 19, further comprising a reference resolver for resolving references as needed by the dereferencer when encountering a segment reference to a segment that is not present in the persistent segment store.

21. In a network wherein a client initiates connections to a server and the network carries request messages from the client to the server over the connections and the network carries response messages from the server to the client over the connections and wherein the client communicates with a first proxy over a first connection, the server communicates with a second proxy over a second connection, and the first proxy and the second proxy communicate with one another over a third connection, a server side transaction accelerator, comprising:

a) the second proxy coupled to the server for receiving response messages for delivery to clients over the second connection, for relaying reconstructed request messages from clients to the server over the second connection, and for sending an accelerated payload to the first proxy over the third connection, and for receiving an accelerated payload from the first proxy over the third connection;

b) a transaction transformer for transforming a response message received from the second proxy comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the response message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a request message payload into a reconstructed request message when the request message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the request message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer.

22. The server side transaction accelerator of claim 21, further comprising a reference resolver for resolving references as needed by the dereferencer when encountering a segment reference to a segment that is not present in the persistent segment store.

23. In a network wherein a client initiates connections to a server and the network carries request messages from the client to the server over the connections and the network carries response messages from the server to the client over the connections and wherein the client communicates with a first proxy over a first connection, the server communicates with a second proxy over a second connection, and the first proxy and the second proxy communicate with one another over a third connection, an improvement comprising:

a client side transaction accelerator, comprising;

a) the first proxy coupled to the client for receiving request messages for delivery to servers over the first connection, for relaying reconstructed response messages from the servers to the client over the first connection, for sending an accelerated payload to the second proxy over the third connection, and for receiving an accelerated payload from the second proxy over the third connection;

b) a transaction transformer for transforming a request message received from the first proxy comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the request message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a response message payload into a reconstructed response message when the response message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the response message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer; and

a server side transaction accelerator, comprising;

a) the second proxy coupled to the server for receiving response-messages for delivery to clients over the second connection, for relaying reconstructed request messages from clients to the server over the second connection, and for sending an accelerated payload to the first proxy over the third connection, and for receiving an accelerated payload from the first proxy over the third connection;

b) a transaction transformer for transforming a response message received from the second proxy comprising a replacer for determining whether to represent the segment data of each segment as an unreferenced segment or as a referenced segment;

c) a persistent segment store that stores segment data and segment references for referenced segments of the response message payload, wherein segments with distinct segment data have distinct segment references and the distinct segment references can be independent of the transaction in which the segment reference was created; and

d) an inverse transaction transformer for untransforming a request message payload into a reconstructed request message when the request message has been accelerated, comprising;

i) a tokenizer that determines where segment references appear in the request message payload; and

ii) a dereferencer for substituting segment data from the persistent segment store for each segment reference detected by the tokenizer.

24. The improvement of claim 23, further comprising:

a client side reference resolver for resolving references as needed by the client side dereferencer when encountering a segment reference to a segment that is not present in the client side persistent segment store; and

a server side reference resolver for resolving references as needed by the server side dereferencer when encountering a segment reference to a segment that is not present in the server side persistent segment store.