Symbolic Computing with Beowulf-Class PC Clusters

Abstract

Beowulf-class systems are an extremely inexpensive way of aggregating substantial quantities of a given resource to facilitate the execution of different kinds of potentially large workloads. Beowulf-class systems are clusters of mass-market COTS PC computers (e.g. Intel Pentium III) and network hardware (e.g. Fast Ethernet, Myrinet) employing available Unix-like open source systems software (e.g. Linux) to deliver superior price-performance and scalability for a wide range of applications. Initially, Beowulfs were assembled to support compute intensive applications at low cost by integrating a large number of microprocessors primarily for science and engineering problems. But over the last few years, this class of clusters has expanded in scale, application domain, and means of use to embrace a much broader range of user problem. Beowulfs have become equally important as a means of integrating large numbers of disk drives to realize large mass storage support systems for both scientific and commercial applications including data bases and transaction processing and are becoming a major workhorse for web servers and search engines. Yet, Beowulf-class systems are able to assemble together large ensembles of yet another type of resource: memory. This possibility may enable domains of computation so far largely unaddressed by the distributed cluster community.

One such problem domain is symbolic computing which allows the representation and manipulation of abstract relationships among abstract objects. Once the principal tool of artificial intelligence (AI), symbolic computing has received less work than other domains as AI had garnered less attention. In the decades of the 1970s and 1980s, symbolic computation was the focus of significant effort with the development of such languages as Prolog, Scheme, OPS-5, and Common Lisp, as well as special purpose computers such as the Symbolics 3600 series and the TI Explorer. In addition, parallel symbolic computation was explored with such multiprocessor based systems as Concert and Multilisp. However, with the failure of AI to deliver results commensurate with the hype that surrounded it and the advent of more conventional RISC based systems that out performed the slower special purpose microprogrammed controlled systems, the focus on symbolic processing diminished leaving only small pockets of research in natural language processing and robotics among a few such areas. One of the factors that greatly hampered success in this regime was the inadequacy of the memory systems. Symbolic computation is memory intensive, easily consuming an order of magnitude or more of memory compared to conventional applications. Beowulf-class systems offer an alternative path to achieving large memory systems at moderate cost. A Beowulf today can provide on the order of a thousand times the memory capacity available to symbolic computing problems of the late 1980s with total memory system prices (including PC nodes and networks) of significantly less than $10 per MByte.

The Beowulf Common Lisp (BCL) project is exploring the application of Beowulf class systems to scalable symbolic computation. The motivation is driven both by the opportunity that Beowulf-class systems provide through their large aggregate memory capacities and by the potential application of symbolic computing to knowledge extraction and manipulation in the realm of large scientific applications. BCL is experimenting with a merger of distributed memory hardware and a programming model based on a global name space. The semantics of Common Lisp incorporate a number of intrinsic constructs which are inherently parallel, many of which lend themselves to distributed computing. One class of such constructs is the set of functional or value oriented operators that employ copies of argument structures. Functional semantics is well known for ease of parallelization and work cast in this form can be readily distributed across cluster nodes. Common Lisp incorporates a second set of constructs referred to as mapping functions that are intrinsically parallel permitting data parallel computation across corresponding elements of complex data structures. In addition, many Lisp operators permit out of order evaluation of arguments yielding yet more natural parallelism. Some of these instructions have corresponding operators that impose ordered evaluation (e.g. LET, LET*) providing synchronization where necessary. The CLOS object oriented system is one of the most powerful in language design and provides a natural program representation for parallel distribution, as well as synchronization, and encapsulation. Finally, while not part of the formal Common Lisp language, the “futures” construct developed initially by Hewitt and later by Halstead provides an important semantic tool for distributed coordination of symbolic functions at different levels of abstraction.

There are many challenges to realizing an effective Beowulf Common Lisp. These include a distributed name space directory, movement of structures and processes across system nodes, dynamic memory management with automatic garbage collection, mapping between the Lisp semantics and the MPI to hide the explicit message passing mechanisms from the programmer, and a distributed form of CLOS for BCL. This talk will describe these challenges and the path being pursued along with preliminary results showing both the feasibility and early functionality. It is believed that the availability of a scalable distributed Common Lisp for Beowulf class systems will provide an impetus to the application of symbolic computing to scientific computing and automatic knowledge abstraction extraction.