Patent Publication Number: US-7587449-B2

Title: Method and system for calculating performance metrics using backchannel messaging and information pattern matching

Description:
TECHNICAL FIELD 
     The described technology is directed generally to testing software applications and, more particularly, to measuring server performance characteristics. 
     BACKGROUND 
     The proliferation of computers and the advent of the Internet and the maturing of the World Wide Web (“web”) have resulted in the development of new and improved software applications for both business and personal uses. Examples of software applications include collaboration applications, chat room applications, instant messaging applications, conferencing applications, gaming applications, and the like. These software applications are commonly based on the client-server paradigm, where the software application or system is split between server tasks and client tasks. In client-server terminology, the client sends a request to the server, according to some protocol, typically asking the server to perform an action and the server responds to the client&#39;s request. These servers are often tested prior to commercial release in order to ensure proper operation of the servers. 
     One aspect of application testing focuses on ensuring reliable operation of a server under anticipated loads. Load testing is a process by which a server is tested under load—i.e., stress—that the server is likely to experience in a real operation environment. Load tests are end-to-end performance tests that test the server under an anticipated production load, which is typically based on a prediction of how the end users—i.e. clients—would use the server. One objective of the load tests is to measure the capability of the server to function correctly under load. Another objective of the load tests is to determine the response times—i.e., performance—for various operations performed by the server. 
     There are a number of traditional approaches to measuring the performance of a server. One approach is to use measurement tools that execute on the server, and which allows for the measurement of the time duration between when the server receives a command request until when the server responds with a command response. While this approach may be adequate for measuring performance within the server, this approach does not provide a true end-to-end performance measurement since it fails to account for the time taken for the command request to go from an issuing client to the server, and the time taken for the command response to go from the server to the clients that are affected by the command request—i.e., the clients that should receive a response from the server as a result of the command request. 
     Another approach is to use measurement tools that execute on the client, and which allow for the measurement of the time duration between when the client issues a command request to a server until when the client receives a command response from the server. This approach may be adequate for measuring the performance of requests that only affect the issuing client if the client does not make further command requests to the server until receiving the command response to the first command request. This is because the command response does not identify the client that originally made the command request that caused this command response. Even if this approach may be adequate for measuring the performance of commands that only affect the issuing client, this approach does not provide a true end-to-end performance measurement of commands that affect clients other than the issuing client for at least the reason stated above. 
     It would be desirable to have a technique that allows for measuring performance characteristics in a client-server environment without requiring the server to correlate command responses to command requests. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a high-level block diagram illustrating an environment in which the described techniques may operate. 
         FIG. 2  is a flow diagram that illustrates the processing of a client when it sends a command request to a server, according to one embodiment. 
         FIG. 3  is a flow diagram that illustrates the processing of a client when it receives a command response from a server, according to one embodiment. 
         FIG. 4  is a flow diagram that illustrates the processing of a client when it receives a backchannel message, according to one embodiment. 
         FIG. 5  is a flow diagram that illustrates the processing of a client when it purges unmatched entries in its request-response matching table, according to one embodiment. 
         FIG. 6  is a display description illustrating how a client matches command requests and command responses, according to one embodiment. 
         FIG. 7  is a display description illustrating how a client purges unmatched entries in its request-response matching table, according to one embodiment. 
     
    
    
     DETAILED DESCRIPTION 
     A method and system for measuring server performance characteristics in a client-server environment is provided. In particular, the measurement techniques allow for measuring server performance at the client without requiring the server to correlate command responses to command requests. In one embodiment, the clients that are testing the server utilize backchannel messaging and information matching logic to calculate server performance—e.g., activity latencies—at the clients without involving the server in the performance measurement process. The backchannel messaging infrastructure facilitates the relaying of a message or messages to all clients, a select group of clients, or a single client. The information matching logic measures server performance by matching command requests and command responses based on message types, identification of the sender (i.e., the client that generated the original command request), and identifier attributes that are unique to the command requests and command responses. 
     In one embodiment, a client generates a message containing an activity start timestamp (also referred to as a “command timestamp”) and a command identifier when sending a command request to a server. The client sends the message—i.e., the backchannel message—to all interested clients using the backchannel messaging mechanism. The interested clients are the clients that should be receiving a command response from the server as a result of the command request. Upon receiving the backchannel message, a client first attempts to match the received backchannel message to a previously received command response. If a match is found, the client calculates the activity latency. If a match is not found, the client stores the attributes contained in the backchannel message in the request-response matching table. The sending client—i.e., the client that originated the backchannel message, may store the attributes contained in the backchannel message in its request-response matching table. For example, the sending client creates an entry in the table for the backchannel message if it expects to receive a command response from the server as a result of sending the command request. 
     When the clients (which may or may not include the original sender of the command request based on the command request) receive a command response from the server, each client generates an activity end timestamp (also referred to as a “command response timestamp”) based on when the client received the command response. Each client then tries matching the command response to the backchannel messages stored in its request-response matching table based on a combination of identifier attributes of the command request and the command response. If a match is found, the client calculates activity latency as the time difference between the activity start timestamp and the activity end timestamp. If a match is not found, the client stores the attributes contained in the command response in the request-response matching table, in order to possibly match the command response to a later-arriving backchannel message, and to calculate the corresponding activity latency. 
     The performance measurement taken at each of the clients can also be gathered to calculate an aggregate or average performance measurement across a representative sample—i.e., multiple clients. 
       FIG. 1  is a high-level block diagram illustrating an environment in which the described techniques may operate. As depicted, the environment comprises clients  102 - 106  coupled to a server  108  through a network  110 , and each client is also coupled to a backchannel messaging component  112 . In general terms, the clients are client application test programs that are used to test the performance of the server by making requests to the server to perform actions, receiving responses from the server, and measuring the end-to-end performance of the server. As such, the clients may be developed using components, such as the dynamic link libraries and the lower-level API, of the native client application of the server. Each client comprises logic to send command request messages, receive command response messages, match the received command response messages to their corresponding requests, and send and receive backchannel messages. The server is the server under test, and may be any server application for which performance testing is desired. 
     The network is a communications link that facilitates the transfer of electronic content between, for example, the clients and the server. In one embodiment, the network includes the Internet. It will be appreciated that the network may be comprised of one or more other types of networks, such as a local area network, a wide area network, a point-to-point dial-up connection, and the like. It will also be appreciated that the network may not be present. For example, clients and the server may both reside on the same computing system and communicate via communication mechanisms, such as, interprocess communication, remote function call, internal communication buses, etc., typically supported on the computing system. 
     The backchannel messaging component facilitates communications between the coupled clients. The backchannel messaging component utilizes a transport mechanism, such as TCP/IP, to enable a client to send backchannel messages to a targeted client or to a group of clients, including all the clients, using target client identifiers and/or target addressing types. In one embodiment, each client establishes a communication channel between itself and the backchannel messaging component. Upon establishing the communication channel, the client may send a backchannel message specifically addressed to a targeted client to the backchannel messaging component, causing the backchannel messaging component to relay the backchannel message to the targeted client. The client may also send a backchannel message addressed to a group of clients—e.g., multi-cast or broadcast—to the backchannel messaging component, causing the backchannel messaging component to relay the backchannel message to each client in the addressed group. The address may be an actual address, such as a network address, or some other identifier that identifies the clients. For example, the address may be a user name with which a client is identified by the server. In another example, assuming an environment where the server is a collaboration server capable of hosting meeting, the address may identify all attendees in a particular meeting, the presenters in a particular meeting, the attendees in a particular meeting, etc. 
     In another embodiment, the clients may send and receive backchannel messages using a network, such as network  110 . For example, each client may establish a communication channel via the network with each of the other clients. The collection of these communication channels may be considered the backchannel messaging component, and the clients may then send backchannel messages to another client or multiple clients using the established communication channels. 
     In one embodiment, each client creates and utilizes a request-response matching table to match command response messages received from the server to their matching command requests in order to calculate end-to-end server performance in processing the command request. By way of example, the request-response matching table contains the following nine columns, with their column definitions:
         command index: uniquely identifies each entry (row) in the table;   command type: identifies the activity the server is requested to perform;   command timestamp: timestamp when the command request was sent by the sending client (this is the time generated on the client);   matching parameters: information other than or in addition to the command type, and which is needed to identify a command request or a command response;   client ID: identifies the client that sent the command request to the server;   command response type: identifies type of command response received from the server;   response timestamp: timestamp when the command response was received;   result: matching result for the entry/record (state of the record); and   timer ID: identifies the timeout timer for the entry/record.       

     The request-response match table and, in particular, the client&#39;s use of the request-response matching table is further discussed below. 
     The computer systems on which the server, the clients, the backchannel messaging component, and other components described herein can execute may include a central processing unit, memory, input devices (e.g., keyboard and pointing devices), output devices (e.g., display devices), and storage devices (e.g., disk drives). The memory and storage devices are computer-readable media that may contain instructions that implement the server application, client application, and other components. In addition, the data structures and message structures may be stored or transmitted via a data transmission medium, such as a signal on a communications link. Various communication links may be used, such as the Internet, a local area network, a wide area network, a point-to-point dial-up connection, a cell phone network, and so on. 
     Embodiments of the described techniques may be implemented in various operating environments that include personal computers, server computers, computing devices, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, programmable consumer electronics, digital cameras, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and so on. The computer systems may be cell phones, personal digital assistants, smart phones, personal computers, programmable consumer electronics, digital cameras, and so on. 
     The techniques may be described in the general context of computer-executable instructions, such as program modules, executed by one or more computers or other devices. Generally, program modules include routines, programs, objects, components, data structures, and so on that perform particular tasks or implement particular abstract data types. Typically, the functionality of the program modules may be combined or distributed as desired in various embodiments. 
       FIG. 2  is a flow diagram that illustrates the processing of a client when it sends a command request to a server, according to one embodiment. By way of example, the server being tested may be a collaboration server that is hosting a plurality of meetings, and the clients may be testing the server to generate latency metrics. In block  202 , a client that is about to request a server activity determines an activity start timestamp for the command request. The client may determine the activity start timestamp from its system clock. In block  204 , the client sends the command request to the server. The activity start timestamp records, as accurately as possible, the time that the command request is sent to the server. In block  206 , the client sends a backchannel message through the backchannel messaging component to the interested clients. The backchannel message corresponds to the command request that was sent to the server, and identifies the activity that was requested of the server in the command request, any additional information that is needed to identify the corresponding command request type, and the time the activity was requested—i.e., the activity start time. The interested clients are the clients that should be receiving a command response from the server as a result of the activity requested in the command request. In block  208 , the client that sent the command request to the server checks to determine whether it is going to receive a command response from the server as a result of the activity requested in the command request. If the client determines that it should receive a command response, then, in block  210 , the client creates an entry in its command-request matching table for the backchannel message that it sent to the interested clients. Subsequent to creating an entry in the request-response matching table, or determining that it should not receive a command response from the server, the client is done processing the sending of the command request, and continues processing, for example, other commands. In another embodiment, if the client expects to also receive a command response, the client can include itself as an interested client when sending the backchannel message, which will cause the client to also receive the backchannel message. 
     One skilled in the art will appreciate that, for this and other processes and methods disclosed herein, the functions performed in the processes and methods may be implemented in differing order. Furthermore, the outlined steps are only exemplary, and some of the steps may be optional, combined with fewer steps, or expanded into additional steps without detracting from the essence of the invention. 
       FIG. 3  is a flow diagram that illustrates the processing of a client when it receives a command response from a server, according to one embodiment. Continuing the above example, the client may be one of the clients that are testing the server to generate latency metrics. In block  302 , the client receives a command response from the server. The command response may be a response from the server to an activity that was requested in a prior command request. In block  304 , the client generates a response timestamp for the received command response. The client may determine the response timestamp from its system clock. The response timestamp records, as accurately as possible, the time that the command response was received by the client. In block  306 , the client checks to determine whether the received command response matches an entry for a backchannel message—i.e., the command request messages sent to the server—in its request-response matching table. In one embodiment, the client determines whether there is a match based on attributes, such as message type and other identifier attributes that are unique to the received command response and its matching command request. 
     If the client determines that the received command response does not match any entry in its request-response matching table, then in block  308 , the client creates an entry in its request-response matching table that corresponds to the received command response. In one embodiment, the client retrieves from the received command response parameters, such as the command response type and other additional information that is needed to identify the corresponding command response type, and stores this information, along with the corresponding command response timestamp, as a new entry in the request-response matching table. The client makes this entry in order to account for latencies or delays in the backchannel messaging component. For example, in the case where the backchannel message that corresponds to this command response arrives at the client at a later point in time, the client will be able to match the received command response to the later-arriving backchannel message. 
     If the client determines that the received command response matches an entry in its request-response matching table, then in block  310 , the client calculates the activity latency. In one embodiment, the client calculates the activity latency as the difference between the command timestamp recorded in the matching entry in the request-response matching table—i.e., the activity start timestamp—and the command response timestamp corresponding to the received command response. Thus, the calculated activity latency is a measurement of the time taken from the time the command request was sent at the originally requesting client to the time the response to the command request was received at this particular client. In order to correctly calculate latencies, the system clocks of the clients that are involved need to be synchronized. In one embodiment, the clients may synchronize their system clocks by executing, for example, Network Time Protocol (NTP) clients. In one embodiment, the client may “complete” the matching entry in the request-response matching table by filling in the information from the received command response, and indicate that the entry was successfully matched. In block  312 , the client purges prior unmatched entries from its request-response matching table. Subsequent to creating an entry in the request-response matching table, or calculating the activity latency associated with the received command response, the client continues processing, for example, other commands. Purging unmatched entries is further discussed below in conjunction with  FIG. 5 . 
       FIG. 4  is a flow diagram that illustrates the processing of a client when it receives a backchannel message, according to one embodiment. Continuing the above example, the client may be one of the clients that are testing the server to generate latency metrics. In block  402 , the client receives a backchannel message. In block  404 , the client checks to determine whether the received backchannel message matches an entry for a previously received command response from the server in its request-response matching table. In one embodiment, the client determines whether there is a match based on attributes, such as message type and other identifier attributes that are unique to the received backchannel message and its matching command response. 
     If the client determines that the received backchannel message does not match any entry in its request-response matching table, then in block  406 , the client creates an entry in its request-response matching table that corresponds to the received backchannel message. In one embodiment, the client retrieves from the received backchannel message parameters, such as the command type and other additional information that is needed to identify the command type, and stores this information, along with the corresponding command timestamp and the identifier for the sending client (the client that sent both the backchannel message and the command request message to the client), as a new entry in the request-response matching table. The client may be able to determine the sending client from, for example, the protocol addressing used to send the backchannel message. In block  408 , the client sets a timer for the received backchannel message. The timer may be a predetermined duration of time within which the matching command response message is to be received from the server. If the timer expires before the matching command response message is received, the client may generate an error condition and/or log the failure/error. 
     If the client determines that the received backchannel message matches an entry in its request-response matching table, then in block  410 , the client calculates the activity latency. In block  412 , the client purges prior unmatched entries from its request-response matching table. Subsequent to setting a timer for the newly created entry in the request-response matching table for the received backchannel message, or calculating the activity latency associated with the received backchannel message, the client continues processing, for example, other commands. 
       FIG. 5  is a flow diagram that illustrates the processing of a client when it purges unmatched entries in its request-response matching table, according to one embodiment. At each client, upon finding a request-response match, the client removes from its request-response matching table all unmatched entries that are from the same original sender—i.e., the sender that sent the command request message to the server—and that are of the same request and response message type—i.e., the same type of activity—as the matched entry. This accounts for the instance where a command response message was not received at a client due to, for example, the client not being running at the time or network problems, or the client was erroneously sent a backchannel message. One skilled in the art will appreciate that the purging of the unmatched entries assumes a FIFO (first-in-first-out) server. The communication channel, between the server and the client, used to send commands and receive responses is also FIFO. For example, if the server receives a request for activity “A” and then receives a request for activity “B,” the server will perform activity “A” and then activity “B.” 
     In block  502 , the client retrieves the contents of the “client ID” field, “command type” field, and “command response type” field from the matched entry in the request-response matching table. Then, for each prior unmatched entry in the request-response matching table (block  504 ), the client performs blocks  506  to  512 , until all the unmatched entries are processed (block  514 ). In block  506 , the client checks to determine whether the retrieved client ID matches the client ID of the unmatched entry in the request-response matching table. If the retrieved client ID does not match the client ID of the unmatched entry in the request-response matching table, the client proceeds to process the next unmatched entry in the request-response matching table. 
     If the retrieved client ID matches the client ID of the unmatched entry in the request-response matching table, the client checks for either matching “command types” or matching “command response types.” In block  508 , the client checks to determine whether the retrieved command type matches the command type of the unmatched entry in the request-response matching table. If the retrieved command type does not match the command type of the unmatched entry in the request-response matching table, the client, in block  510 , checks to determine whether the retrieved command response type matches the command response type of the unmatched entry in the request-response matching table. If the retrieved command response type does not match the command response type of the unmatched entry in the request-response matching table, then the client proceeds to process the next unmatched entry in the request-response matching table. 
     If the retrieved command type matches the command type of the unmatched entry in the request-response matching table (block  508 ) or the retrieved command response type matches the command response type of the unmatched entry in the request-response matching table (block  510 ), then, in block  512 , the client purges the unmatched entry from the request-response matching table, and the purged entry is not used for subsequent matches. For example, the client may indicate in the “result” field that there is no match for the entry. 
       FIG. 6  is a display description illustrating how a client matches command requests and command responses, according to one embodiment. In the illustrated example, the server may be hosting a meeting in which the two clients, “Client A” and “Client B” are the participants. Even though the example illustrates the matching technique using only two clients, one skilled in the art will appreciate that the illustrated technique need not be so limited, and that the technique may readily apply to any number of clients. 
     Client A sends a command request message to the server requesting the server to flip slide to slide # 2  at time 12:00:01 (Stage  1 ). Upon sending this command request message, Client A creates a new entry (entry # 99 ) in its request-response matching table that corresponds to the command request message since Client A expects to receive a command response message from the server. Client A indicates in entry # 99  that the command type is “flip slide,” the command timestamp is “12:00:01,” the matching parameters are “slide # 2 ,” the client ID is “A,” and the timer ID is “T 99 .” Client A then sends a backchannel message that corresponds to the command request message to all the interested clients, which, in this example, is Client B (Stage  2 ). 
     Client B sends a command request message to the server requesting the server to flip slide to slide # 5  at time 12:00:02 (Stage  3 ). Upon sending this command request message, Client B creates a new entry (entry # 201 ) in its request-response matching table that corresponds to the command request message since Client B expects to receive a command response message from the server. Client B indicates in entry # 201  that the command type is “flip slide,” the command timestamp is “12:00:02,” the matching parameters are “slide # 5 ,” the client ID is “B,” and the timer ID is “T 201 .” Subsequent to creating entry # 201 , Client B receives the backchannel message regarding slide # 2  (Stage  4 ). Upon receiving the backchannel message, Client B checks the unmatched entries in its request-response matching table to see if there is an unmatched entry that matches the backchannel message. Unable to find a matching entry, Client B creates a new entry (entry # 202 ) in its request-response matching table that corresponds to the backchannel message. Client B indicates in entry # 202  that the command type is “flip slide,” the command timestamp is “12:00:01,” the matching parameters are “slide # 2 ,” the client ID is “A,” and the timer ID is “T 202 .” Client B then sends a backchannel message that corresponds to the command request message to all the interested clients, which, in this example, is Client A (Stage  5 ). 
     Client A and Client B each receives a command response message from the server to show slide # 2  (Stage  6 ). Upon receiving this command response message, Client A determines that the message was received at time 12:00:05, and identifies from the command response message that the command response type attribute is “show slide” and the matching parameters attributes are “slide # 2 .” Client A uses the identified attributes to check the unmatched entries in its request-response matching table—i.e., entry # 99 —to see if there is a match. With regard to entry # 99 , Client A determines that the command response type “show slide” matches the command type “flip slide,” and that the matching parameters from entry # 99  and from the command response message are the same. Upon determining that entry # 99  matches the command response message, Client A completes the remaining fields of entry # 99  to indicate a match and cancels the timeout timer T 99 . As depicted, Client A indicates in entry # 99  that the command response type is “show slide,” the response timestamp is “12:00:05,” and the result is “success.” 
     As for Client B, upon receiving the command response message, Client B determines that the message was received at time 12:00:05, and identifies from the command response message that the command response type attribute is “show slide” and the matching parameters attributes are “slide # 2 .” Client B uses the identified attributes to check the unmatched entries in its request-response matching table—i.e., entry # 201  and entry # 202 —to see if there is a match. With regard to entry # 201 , Client B determines that, while the command response type “show slide” matches the command type “flip slide,” the matching parameters “slide # 2 ” does not match “slide # 5 ,” and thus, entry # 201  fails to match the command response message. With regard to entry # 202 , Client B determines that the command response type “show slide” matches the command type “flip slide,” and that the matching parameters from entry # 202  and from the command response message are the same. Upon determining that entry # 202  matches the command response message, Client B completes the remaining fields of entry # 202  to indicate a match and cancels the timeout timer T 202 . As depicted, Client B indicates in entry # 202  that the command response type is “show slide,” the response timestamp is “12:00:05,” and the result is “success.” 
     Client A and Client B each receives a command response message from the server to show slide # 5  (Stage  7 ). Upon receiving this command response message, Client A determines that the message was received at time 12:00:08, and identifies from the command response message that the command response type attribute is “show slide” and the matching parameters attributes are “slide # 5 .” Client A uses the identified attributes to check the unmatched entries in its request-response matching table to see if there is a match. Unable to find a matching entry, Client A creates a new entry (entry # 100 ) in its request-response matching table that corresponds to the received command response message. Client A indicates in entry # 100  that the command response type is “show slide,” the response timestamp is “12:00:08,” and the matching parameters are “slide # 5 .” 
     As for Client B, upon receiving the command response message, Client B determines that the message was received at time 12:00:08, and identifies from the command response message that the command response type attribute is “show slide” and the matching parameters attributes are “slide # 5 .” Client B uses the identified attributes to check the unmatched entries in its request-response matching table—i.e., entry # 201 —to see if there is a match. With regard to entry # 201 , Client B determines that the command response type “show slide” matches the command type “flip slide,” and that the matching parameters from entry # 201  and from the command response message are the same. Upon determining that entry # 201  matches the command response message, Client B completes the remaining fields of entry # 201  to indicate a match and cancels the timeout timer T 201 . As depicted, Client B indicates in entry # 201  that the command response type is “show slide,” the response timestamp is “12:00:08,” and the result is “success.” 
     Client A then receives the backchannel message regarding slide # 5  (Stage  8 ). Upon receiving the backchannel message, Client A identifies from the backchannel message that the command type attribute is “flip slide” and the matching parameters attributes are “slide # 5 .” Client A uses the identified attributes to check the unmatched entries in its request-response matching table—i.e., entry # 100 —to see if there is a match. With regard to entry # 100 , Client A determines that the command type “flip slide” matches the command response type “show slide,” and that the matching parameters from entry # 100  and from the backchannel message are the same. Upon determining that entry # 100  matches the backchannel message, Client A completes the remaining fields of entry # 100  to indicate a match. As depicted, Client A indicates in entry # 100  that the command type is “flip slide,” the response timestamp is “12:00:02,” the client ID is “B,” and the result is “success.” 
       FIG. 7  is a display description illustrating how a client purges unmatched entries in its request-response matching table, according to one embodiment. Similar to the example above, Client A sends a command request message to the server requesting the server to flip slide to slide # 2  at time 12:00:01 (Stage  1 ). Upon sending this command request message, Client A creates a new entry (entry # 99 ) in its request-response matching table that corresponds to the command request message since Client A expects to receive a command response message from the server. Client A indicates in entry # 99  that the command type is “flip slide,” the command timestamp is “12:00:01,” the matching parameters are “slide # 2 ,” the client ID is “A.” Client A then sends a backchannel message that corresponds to the command request message to all the interested clients, which, in this example, is Client B (Stage  2 ). 
     Client A then receives a backchannel message regarding slide # 5  from Client B (Stage  3 ). Upon receiving the backchannel message, Client A checks the unmatched entries in its request-response matching table to see if there is an unmatched entry that matches the backchannel message. Unable to find a matching entry, Client A creates a new entry (entry # 100 ) in its request-response matching table that corresponds to the backchannel message. Client A indicates in entry # 100  that the command type is “flip slide,” the command timestamp is “12:00:02,” the matching parameters are “slide # 5 ,” and the client ID is “B.” Client A then receives another backchannel message regarding slide # 6  from Client B (Stage  4 ). Upon receiving the backchannel message, Client A checks the unmatched entries in its request-response matching table to see if there is an unmatched entry that matches the backchannel message. Unable to find a matching entry, Client A creates a new entry (entry # 101 ) in its request-response matching table that corresponds to the backchannel message. Client A indicates in entry # 101  that the command type is “flip slide,” the command timestamp is “12:00:03,” the matching parameters are “slide # 6 ,” and the client ID is “B.” 
     Client A then receives a command response message from the server to show slide # 2  (Stage  5 ). Upon receiving this command response message, Client A determines that the message was received at time 12:00:05, and identifies from the command response message that the command response type attribute is “show slide” and the matching parameters attributes are “slide # 2 .” Client A uses the identified attributes to check the unmatched entries in its request-response matching table—i.e., entry # 99 - 101 —to see if there is a match. With regard to entry # 99 , Client A determines that the command response type “show slide” matches the command type “flip slide,” and that the matching parameters from entry # 99  and from the command response message are the same. Upon determining that entry # 99  matches the command response message, Client A completes the remaining fields of entry # 99  to indicate a match. As depicted, Client A indicates in entry # 99  that the command response type is “show slide,” the response timestamp is “12:00:05,” and the result is “success.” Having found a match, Client A does not need to check the other unmatched entries. 
     Client A then receives a command response message from the server to show slide # 6  (Stage  6 ). Upon receiving this command response message, Client A determines that the message was received at time 12:00:08, and identifies from the command response message that the command response type attribute is “show slide” and the matching parameters attributes are “slide # 6 .” Client A uses the identified attributes to check the unmatched entries in its request-response matching table—i.e., entry # 100  and entry # 101 —to see if there is a match. With regard to entry # 100 , Client A determines that, while the command response type “show slide” matches the command type “flip slide,” the matching parameters “slide # 6 ” does not match “slide # 5 ,” and thus, entry # 100  fails to match the command response message. With regard to entry # 101 , Client A determines that the command response type “show slide” matches the command type “flip slide,” and that the matching parameters from entry # 101  and from the command response message are the same. Upon determining that entry # 101  matches the command response message, Client A completes the remaining fields of entry # 101  to indicate a match. As depicted, Client A indicates in entry # 101  that the command response type is “show slide,” the response timestamp is “12:00:08,” and the result is “success.” 
     Subsequent to finding a matching entry in the request-response table, Client A checks all preceding unmatched entries in the request-response table to determine whether the unmatched entry should be purged from the table. In one embodiment, the client purges all unmatched entries that are from the same original sender and of the same request and response message type as the matched entry. In this instance, Client A checks unmatched entry # 100  and determines that it has the same client ID and the command type as the matched entry (entry # 101 ). Thus, Client A purges entry # 100  from its request-response matching table so that it will not be used in a subsequent match. For example, Client A indicates in entry # 100  that the result is “failure.” 
     From the foregoing, it will be appreciated that embodiments of the invention have been described herein for purposes of illustration, but that various modifications may be made without deviating from the spirit and scope of the invention. Accordingly, the invention is not limited except in accordance with elements explicitly recited in the appended claims.