Flexible and Optimized IDL Compilation for Distributed Applications

Eric Eide, Jay Lepreau, and James L. Simister
University of Utah Department of Computer Science
3190 MEB, Salt Lake City, Utah 84112
flick@cs.utah.edu
http://www.cs.utah.edu/flux/flick/

Abstract

The author of a distributed system is often faced with a dilemma when writing the system's communication code. If the code is written by hand (e.g., using Active Messages) or partly by hand (e.g., using MPI) then the speed of the application may be maximized, but the human effort required to implement and maintain the system is greatly increased. On the other hand, if the code is generated using a high-level tool (e.g., a CORBA IDL compiler) then programmer effort will be reduced, but the performance of the application may be intolerably poor. The tradeoff between system performance and development effort arises because existing communication middleware is inefficient, imposes excessive presentation layer overhead, and therefore fails to expose much of the underlying network performance to application code. Moreover, there is often a mismatch between the desired communication style of the application (e.g., asynchronous message passing) and the communication style of the code produced by an IDL compiler (synchronous remote procedure call). We believe that this need not be the case, but that established optimizing compiler technology can be applied and extended to attack these domain-specific problems.

We have implemented Flick, a flexible and optimizing IDL compiler, and are using it to explore techniques for producing high-performance code for distributed and parallel applications. Flick produces optimized code for marshaling and unmarshaling data; experiments show that Flick-generated stubs can marshal data between 2 and 17 times as fast as stubs produced by other IDL compilers. Further, because Flick is implemented as a ``kit'' of components, it is possible to extend the compiler to produce stylized code for many different application interfaces and underlying transport layers. In this paper we outline a novel approach for producing ``decomposed'' stubs for a distributed global memory service.

© Springer-Verlag. This paper was presented at the Fourth Workshop on Languages, Compilers, and Run-time Systems for Scalable Computers (LCR '98) in Pittsburgh, PA, May 28-30, 1998. The complete proceedings of the workshop were published by Springer-Verlag as volume 1511 of the Lecture Notes in Computer Science series.