Remote application control for low bandwidth application sharing

• US 6,038,593 A
• Filed: 12/30/1996
• Issued: 03/14/2000
• Est. Priority Date: 12/30/1996
• Status: Expired due to Term

• Current Assignee: Intel Corporation
• Original Assignee: Intel Corporation
• Inventors: Huckins, Jeffrey L.
• Primary Examiner(s): Geckil, Mehmet B.
• Application Number:
  US08/781,901
• Time in Patent Office: 1,170 Days
• Field of Search: 395/200.33, 395/200.47, 395/200.6, 395/200.3, 395/200.77, 707/104, 707/10, 709/200, 709/203, 709/204, 709/205, 709/213, 709/217, 709/227, 709/228, 345/330
• US Class Current: 709/217
• CPC Class Codes: G06F 9/465 Distributed object oriented systems remote method invocation [RMI] G06F9/548

Abstract

An object-oriented distributed service architecture is disclosed as including a client, a "distributed" interface server, and a "local" interface server residing on each computer that is part of an application sharing session. The distributed server communicates with other similar distributed servers on remote computers, and enables a remote implementation of a function invoked by the local client. In response to a function call through a local interface, the distributed server packages an instance identifier for a remote interface residing on a remote machine, together with a function identifier and any arguments required for the function. The message packet is then sent off to remote machines. Each such remote interface had been created as an instance of the local interface in response to a previous message from the local interface. When another distributed server receives the message, the function is invoked through the interface associated with the received instance identifier, resulting in implementation of the function at the remote site.

Claims

1. A computer-implemented method of performing functions on a remote machine, the functions to be invoked by a first application in a local machine, a communication pipe coupling the local and remote machines, the method comprising the steps of:

a) creating a remote-implementation (RI) interface on a local machine, the RI interface defining a function;

b) creating a second local-implementation (LI) interface in a remote machine as an instance of the RI interface;

c) sending an instance identifier for the second LI interface and a function identifier for the function into the communication pipe in response to the first application invoking the function through the RI interface; and

d) performing the function through the second LI interface on the remote machine in response to receiving the instance identifier and the function identifier.

2. The method of claim 1 wherein the step of sending an instance identifier and a function identifier further comprises sending arguments associated with the function.

3. The method of claim 1 wherein the communication pipe supports a reliable multicast protocol, and wherein step a) of claim 1 is performed in each of a plurality of machines coupled to the communication pipe.

4. The method of claim 1 further comprising the steps of:

creating a first LI interface on the local machine as an instance of the RI interface; and

performing the function through the first LI interface on the local machine in response to the first application invoking the function through the RI interface.

5. The method of claim 4 wherein the function is implemented as part of the first application.

6. The method of claim 1 further comprising the steps of

associating a globally unique identifier (GUID) of a LI interface server with a GUID of a RI interface server, both servers residing on the same computer, the LI interface server containing a local implementation of the function, the RI interface server for creating the second LI interface in the remote machine.

7. An object-oriented distributed service architecture comprising:

first and second computers connected by a communication pipe;

first client residing within the first computer and accessing a remote implementation (RI) interface defining a function implemented in the first computer, a second local-implementation (LI) interface created in the second computer as an instance of the RI interface;

first RI interface server residing within the first computer for creating a protocol data unit (PDU) and sending the PDU into the communication pipe in response to the client invoking the function through the RI interface, the PDU including an instance identifier associated with the second LI interface and a function identifier associated with the function; and

second RI interface server residing within the second computer for invoking the function through the second LI interface in response to receiving the PDU from the communication pipe, the function implemented in the second computer.

8. The architecture of claim 7 wherein the communication pipe and first and second RI interface servers support a reliable multicast protocol.

9. The architecture of claim 7 wherein the RI interface creates a first LI interface as an instance of the RI interface, the first LI interface for performing the function on the first computer in response to the first client invoking the function through the RI interface.

10. The architecture of claim 7 wherein the function and the first client are implemented as part an application program.

11. The architecture of claim 10 further comprising a first LI interface server residing in the first computer for creating the first LI interface, the first LI interface server having a globally unique identifier (GUID) associated with a GUID for the first RI interface server.

12. An article of manufacture comprising:

a machine-readable medium having instructions which when executed on a first computer cause the steps of

creating a remote-implementation (RI) interface in the first computer, the RI interface defining a first function being implemented in the first computer and at least one second computer, the first and second computers being connected by a communication pipe; and

sending from the first computer to the second computer an instance identifier of a second local implementation (LI) interface and a function identifier of a function in response to an application program in the first computer invoking the function through the RI interface, the second LI interface being an instance of the RI interface.

13. The article of claim 12 wherein the medium has further instructions which when executed cause the further steps of:

creating a first LI interface in the first computer, the first LI interface being an instance of an original interface in the first computer and used to perform the function in the first computer; and

invoking the function through the LI interface in response to the application program invoking the function through the RI interface.

14. The article of claim 12 including further instructions which when executed cause the step of sending the instance identifier to further comprise:

packaging the instance identifier and the function identifier in a protocol data unit destined for the second computer; and

sending their protocol data unit into the communication pipe.

15. The article of claim 12 further including instructions which when executed on a remote computer cause the further steps of sending the instance identifier and the function identifier to a plurality of computers according to a multicast protocol.

16. An article of manufacture comprising:

a machine-readable medium having instructions which when executed on a remote computer cause the steps of;

creating a local implementation (LI) interface that defines a function which is implemented in the remote computer in response to a message received from a local computer, the LI interface being an instance of and having the same instance identifier as a remote-implementation (RI) interface in the local computer; and

invoking the function through the LI interface in response to receiving the instance identifier of the LI interface and a function identifier of the function from the local computer.

17. An application sharing session comprising:

first user invoking a function supported by an application residing on the user'"'"'s first machine;

creating a remote-implementation (RI) interface on the first user'"'"'s machine, the RI interface defining the function;

creating a local-implementation (LI) interface in a second user'"'"'s machine as an instance of the RI interface, a copy of the application residing on the second user'"'"'s machine;

the first user'"'"'s machine sending an instance identifier for the LI interface and a function identifier for the function to the second user'"'"'s machine in response to the user invoking the function; and

performing the function by the copy of the application in the second user'"'"'s machine through the LI interface in response to receiving the instance identifier and the function identifier.