An Overview of ZPL
ZPL is a new array programming language designed for engineering and scientific programs that would
previously have been written in C or C++. Its design goals were machine independence and high
performance, therefore, ZPL programs run fast on both sequential and parallel
computers. ZPL programs are usually very simple and easy to write. This is because it is
"implicitly parallel," i.e. the programmer does NOT express the parallelism.
ZPL's implicit parallelism is a very useful feature. Because the programmer does not have to figure
out how to split the data to be suitable for parallel processing, ZPL programs are shorter and easier
to write than those written in C with third-party library calls. Let me give an example:
Mercury Computers makes a powerful machine that does parallel processing. Writing a classic parallel
program, "matrix multiplication" is actually fairly complex when using Mercury's native calls.
However, writing the program in ZPL is quite simple.
There is, of course, a tradeoff for this functionality. This tradeoff is remarkably
similar to that of Java and C++. ZPL is easier to write, but is slower than the
equivalent written with Mercury's RACE libraries.
This slowdown would seem to spell the death of ZPL. In the parallel processing
world, speed is everything. However, I do believe there is a chance
that ZPL could become widely used. Program execution speed is critical, but also important
is development time. Development in ZPL is far easier and faster
than in competing languages. One possible solution for complex parallel programming
could be to build a prototype in ZPL, get it working, and then convert it to the system's
native calls. This might seem like too much additional work, however, this development
process is used frequently in the Java/C++ realm. Sometimes it's not about
being the best solution, it's being the first one available.
ZPL Fact Sheet
- Name. ZPL is short for the Z (level) Programming Language; see
programming model, above.
- Origin. ZPL was designed and implemented by the Orca Project
of the Computer Science and Engineering Department at the University of Washington.
- Type. ZPL uses the array abstraction to implement a dataparallel
programming model; it is a standalone subset of Advanced ZPL.
- History. Implementation of the ZPL compiler began in March 1993. It generated
code approximately 15 months later. ZPL will be officially "released" soon.
- Approach. ZPL is translated into a conventional abstract syntax
tree representation on which program analysis and optimizations are performed. ANSI
C code is generated as the object code. This C program is machine independent, and
implements certain operations in abstract form. This code is compiled using the native
C compiler on the target machine with custom libraries. In this second compilation the
abstract operations are customized to the specific platform.
- Team. The creators of ZPL are: Brad Chamberlain, Sung-Eun Choi,
E Christopher Lewis, Calvin Lin, Jason Secosky, Larry Snyder, and W. Derrick Weathersby
with assistance from Ruth Anderson, A.J. Bernheim, Marios Dikaiakos, George Forman, and
- Funding. The foundational research for the ZPL compiler was funded in
part by the Office of Naval Research N00014-89-J-1368. The compiler itself was funded in
part by the Advanced Research Projects Agency, N00014-92-J-1824. Present funding is from ARPA.
Source of information: http://www.cs.washington.edu/research/zpl/