Coign

Coign is an automatic distributed partitioning system (ADPS). It converts local COM applications into distributed client-server applications without access to source code. Using scenario-based profiling, Coign discovers the internal structure of an application and cuts the application into client and server components; choosing a distribution that minimizes communication between client and server.

In layman's terms, Coign takes an single-computer application, as shipped on a CD, watches how you use it, then divides it to run simultaneously on two computers to improve its performance.

Coign is an Automatically Distributed Partitioning System (ADPS) for component-based applications. Given either a non-distributed or distributed application built from COM components, Coign will automatically create a new distributed version of the application. Using scenario-based profiling, Coign creates an inter-component communication (ICC) model of the application. Later at execution time, Coign uses the ICC model to partition the application into client and server components and distribute the components across a network to reduce total communication costs. Coign operates on application binaries (.exe and .dll files); analysis, partitioning, and distribution are achieved with no access to application sources. Coign is language independent.

Coign was part of the Millennium Project at Microsoft Research, a project to develop distributed systems that provide a new level of abstraction for application programmers and users, managing machines and network connections for the programmer in the same way that operating systems today manage pages of memory and disk sectors.

From The American Heritage Dictionary of the English Language:

coign noun

1. A stone serving to form an exterior angle of a wall or other piece of masonry; a cornerstone.
2. A keystone.

You are assigned the task of creating a large client/server application. Users access the application from their PCs. The application manipulates data stored on a server. To economize development time, you build the application from a number of prefabricated software components. Using known techniques, you can readily connect the components to create your custom application.

Difficulties arise when you must partition components between host computers. Components can reside on the user's PC, the centralized server, or possibly a departmental compute server. Factors influencing your decision include computation or memory resources available on each host, network bandwidth and latency, and constraints on the location of components with access to sensitive data. Choosing an optimal distribution is further complicated by the fact that the prefabricated components are binary objects with no source code. Determining communication and resource costs for each component is difficult if not impossible.

Even if you can determine an ideal distribution, evolutionary factors may render it obsolete. Future changes might include the topology of computation resources, network latency, or the need to insert new layers in the component architecture. A sound component distribution coded into the application today might become a serious weakness in the future.

Using Coign, you create an application and leave the details of distribution to the system. After aggregating the necessary prefabricated components and writing the necessary connection code, you are ready to create a distribution version of the application. You instruct the Coign binary re-writing tool to insert the Coign run-time instrumentation into your application. You then run your application through a number of profiling scenarios. Coign's instrumentation discovers which components are used in the application by instrumenting the COM libraries and interfaces at run time. The instrumentation measures all communication between application components.

After completing the profiling scenarios, another Coign tool constructs an abstract model of your application's components and inter-component communication (ICC). The abstract ICC model is network independent. You now deliver the application to your customers. When you customers run your application, a small residual piece of the Coign run time embedded in your application distributes the application to minimize communication costs. Communication is minimized by the Coign runtime which automatically tunes the application's distribution to take into consideration currently k latency and available bandwidth.

The effectiveness of a Coign-chosen distribution is based on how closely the profiling scenarios match a user's usage of the application. Because Coign can re-partition and re-distributed applications without access to application binaries, your customers can even re-profiling the application on site to fully tune the application to their needs.

With Coign, you can create a single application and the Coign ADPS automatically adjust its component distribution as network topology and constraints and customer usage patterns change . You aren't locked into coding a single static distribution choice.

We have completed an initial implementation of Coign on Windows NT. Coign is the first ADPS to automatically distribute binary applications built from components. Coign has successfully distributed three commercial-grade applications: Microsoft PhotoDraw 2000, the Octarine word processor, and the Corporate Benefits Sample from the Microsoft Developer Network (MSDN). In all, Coign has successfully distributed more than 2 million lines of component-based applications. In terms of complexity, several of the Octarine scenarios we have tested instantiate over 3,800 components.

From non-distributed applications, Coign has produced distributed applications with communication costs up to 31% lower than other source-free distribution techniques.

Coign has also proven effective in re-optimizing manually distributed applications. In one case, Coign optimized a 3-tier application to reduce communication costs by 54%.

Coign is completely language neutral because it leverages COM's binary standard interfaces and true location transparency. Coign has distributed applications with components written in Visual Basic, C, C++, and x86 Assembler. All of the applications distributed with Coign were created with no a priori knowledge of the existence of Coign.

Coign has successfully demonstrated that commercial applications can be automatically distributed without access to application sources. Furthermore, Coign has demonstrated that the internal architecture of existing COM-based applications can be exploited to produce distributed applications with good performance.

Papers:

• Galen C. Hunt and Michael L. Scott. The Coign Automatic Distributed Partitioning System. To appear in Proceedings of the 3rd Symposium on Operating Systems Design and Implementation (OSDI'99). New Orleans, LA, February, 1999.
  Also available as MSR-TR-98-40 in Microsoft Word '97, PostScript, and PDF.

• Galen C. Hunt and Michael L. Scott. A Guided Tour of the Coign Automatic Distributed Partitioning System. Proceedings of the 2nd International Enterprise Distributed Object Computing Workshop (EDOC '98), pages 252-262. San Diego, California, November, 1998.
  Also available as MSR-TR-98-32 in Microsoft Word '97, PostScript, and PDF.

• Galen C. Hunt. Automatic Distributed Partitioning of Component-Based Applications. Ph.D. Dissertation, University of Rochester, Rochester, New York, July 1998.
  Available in PDF.

• Galen C. Hunt and Michael L. Scott. Coign: Efficient Instrumentation for Inter-Component Communication Analysis, URCS Tech Report 648, University of Rochester, Rochester, New York, February 1997.