Parallelism and resource selection
Legion achieves high-performance computing by selecting resources based on load and job affinity and through parallel processing.
- High performance via resource selection
Even single task jobs can get better performance when presented with a range of possible execution sites. The user can, for example, choose the host with the lowest load or the greatest power. Power, in this context, might be determined by factors such as performance on the Spec benchmakrs adjusted for load or with the application itself as a benchmark. Either way, Legion's flexible resource management scheme lets user-level scheduling agents choose the right resource. - High performance via parallelism
Parallel processing has been around for some time, on both tightly cupled MPPs and on workstation and PC clusters. Legion supports a distributed mememory parallel computing model, but since Legion's objects are often on different hosts, perhaps thousands of miles apart, communication overhead can run from single digit milliseconds to tens of milliseconds. The result is that Legion is not appropriate for fine-grain parallel programs.Legion can be used for parallel processing in a variety of application styles. It can execute a single application across geographically separate hosts or support meta-applications (e.g., schedule the components of a single meta-application on the nodes of an MPP).
Legion supports parallel processing in four ways:
- Supporting popular parallel libraries, such as MPI
- Supporting parallel languages, such as MPL
- Offering wrap parallel components
- exporting the run-time library interface to library, toolkit, and compiler writers
Support of parallel libraries
The vast majority of parallel applications today are written in MPI and PVM. Legion supports both libraries, via emulation libraries that use the underlying Legion run-time library. Existing applications only need to be recompiled and relinked in order to run on Legion. MPI and PVM users can thus reap the benefits of Legion with existing applications. In the future, libraries such as Scalapak will also be supported.
Parallel language support
Legion supports MPL (Mentat Programming Language) and BFS (Basic Fortran Support). MPL is a parallel C++ language in which the user specifies those classes that are computationally complex enough to warrent parallel execution. Class instances are then used like C++ class instances: the compiler and run-time system take over and construct parallel computation graphs of the program and then execute the methods in parallel on different processors. Legion is written in MPL: BFS is a set of pseudo-comments for Fortran and a preprocessor that gives the Fortran programmer access to Legion objects. It also allows parallel execution via remote asynchronous procedure calls and the construction of program graphs. HPF may also be supported in the future.
Wrap parallel components
Object wrapping is a time-honored traditiion in the object-oriented world. We have extended the notion of encapsulating existing legacy codes into objects by encapsulating parallel components into objects. To other Legion objects the encapsulated object appears sequential but it executes faster. PVM, HPF, and shared memory threaded applications can thus be encapsulated into a Legion object.
Export the run-time library
We do not expect to provide the full range of languages and tools that users require: instead of developing everything here at the University of Virginia, we anticipate Legion becoming an open, community, artifact, to which other tools and languages are ported. To support these third party developments, the complete run-time library is available. User libraries can directly manipulate the run-time library.
The library is completely reconfigurable. It supports basic communication, encryption/decryption, authentication, and exception detection and propagation, as well as parallel program graphs. Program graphs represent functions and are first class and recursive. Graph nodes are member function invocations on Legino objects or sub-graphs. Arcs model data dependencies. Graphs may be annotated with arbitrary information, such as resource requirements, architecture affinities, etc. The annotations may be used by schedulers, fault-tolerance protocols, and other user-defined services.
| Link | Description |
 | |
| Overview | A general look at Legion |
| Objectives and constraints | Legion's design objectives and restrictions |
| Applications | Adapting and running Legion applications |
| Architecture | Legion system architecture |
| High-performance computing | Using Legion to get high-performance computing |
| Scheduling | Scheduling and resource management |
| Security | Legion's security philosophy and model |
