Software Integration Towards Global Computing
Overview
Software Integration Towards Global Computing Chris Faigle, Geoffrey C. Fox, Wojtek Furmanski, Tom Haupt and Janusz Niemiec Northeast Parallel Architectures Center 111 College Place, Syracuse University Syracuse, NY 13244–4100 submitted to the 7th ACM International Conference on Supercomputing, Tokyo, Japan, July 19–23, 1993 December 10, 1992
Abstract We discuss here software integration strategies towards the Global Computing paradigm. This includes supercomputing, broadband networking and virtual reality user interfaces. We use here as a test case the televirtuality based educational environment, currently at the planning stage at NPAC. In this project, we want to re-use Grand Challenges applications as educational tools, restructured to the form of Virtual Worlds, delivered to schools via fiber optic links and sensed there via consumer VR peripherals. This raises non-trivial integration problems, involving software components such as High Performance Fortran, models for distributed computing, Open Systems software for GUIs and VR operating shells. An interpolating paradigm is proposed based on the MOVIE system at NPAC — a scriptable high-level language based operating environment which provides suitable connectivities to individual enabling technologies. In particular, we discuss the MOVIE based High Performance Fortran Interpreter – a new effort at NPAC aimed at reducing the gap between the software technologies for scientific computing and for advanced human-machine front-ends.
Contents 1 2 3 4 5 6 7
Overview . . . . . . . . . . . . . . . . . . . . . . . . . The MOVIE System . . . . . . . . . . . . . . . . . . High Performance Fortran Interpreter . . . . . . . Virtual Reality . . . . . . . . . . . . . . . . . . . . . . Test Case: Grand Challenges as Virtual Worlds Implementation Status . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
ipatory, multi-user, interactive media with suitable natural spatio-temporal metaphors of various computing domains. The new wave of low cost consumer VR products, based on new technologies for high resolution displays and expected at the end of ’93, when combined with the emerging networking infrastructure of NREN [Kahn92] and the coming generation of teraflop computers, will offer the first hardware platform for this new metamedium, referred to as Televirtuality [Jaco92][Stop92] and envisioned by enthusiasts to replace or integrate telephony, television, personal computing and home entertainment electronics.
1 2 3 5 7 7 8
1.
Overview Supercomputing will enter a new phase in the coming years due to the increased availability and speed of computer networks. These so far stand-alone systems, dedicated typically to advanced scientific research or defense projects will be soon exploited for more diversified purposes to eventually serve the community at large. In the compelling scenario of the 21st century information processing infrastructure referred to as Global Computing [ScAm91], gigabit networks of supercomputers will address large to global scale processing tasks when simulating or managing diverse ‘worlds’ such as environment, economy, large corporations, weather, climate, news etc. These and many other InfoSpaces [Barr92] will be accessed via fiber optic links by the end users in terms of suitable interface devices, fully integrated with human sensors. The highest bandwidth solution is achieved in terms of Virtual Reality [MIS91] front-ends, offering the on-line access to immersive, particFaigle, Fox, Furmanski, Haupt & Niemiec
The implementation of such a Global Village [Gore91] raises non-trivial software challenges in the area of scalable heterogeneous high performance distributed computing. Unlike in ‘conventional’ supercomputing, where deficiencies in software standards and user interfaces were so far effectively coped with by motivated individual programmers, the global scale endeavor discussed here must involve broader programmer’s community. In consequence, issues such as scalable portable software for HPC, open models for integration and interoperability in heterogeneous distributed environments, and standards for advanced human-machine interfaces, become critical for the success of the global computing concept. These problems were and are recently pursued by many R&D teams and a substantial progress has been already achieved during last five years. This includes 1
NPAC, Syracuse University
Software Integration Towards Global Computing
Overview
Open Systems standards for network-extensible GUIs such as X, Motif-OpenLook, PHIGS-PEX-OpenGL, first embryonic attempts at industry standards in the area of VR operating shells, several popular communication models for distributed computing such as Express, PVM or Linda, and the first generation of portable parallel languages such as High Performance Fortran and versions of concurrent C++. We expect such list of standardized open software modules to grow and to eventually encompass all critical computational domains, including also databases, expert systems, multimedia, information systems etc. However, the complexity of such heterogeneous collection of software modules is already substantial and it will only continue to grow. A need for a more homogeneous integration paradigm becomes critical in the context of global computing and we focus on this issue in the present document. We will use as a test case a class of televirtuality applications for K-12 education, currently at the planning stage at NPAC. The idea is to re-use Grand Challenges with the educational potential, such as weather forecasting or human anatomy, by restructuring these large research codes to the form of dynamic, interactive Virtual Classes, adapted to the K-12 needs, and accessed at schools via consumer VR within the framework of a Virtual School metaphor. Integration of present software technologies for Grand Challenges and for Virtual Reality towards a televirtuality application exposes in a clear way the ‘impedance mismatch’ between these two extreme programming paradigms. We expect many Grand Challenges to be coded in HPF after the new standard is broadly accepted by the HPC industry. Current focus in the HPF design is on data parallel structures such as Fortran90 arrays and the language provides therefore a suitable portable scalable support for large scale regular computational tasks such as for example PDEs in climate modeling. On the other hand, dynamic, multithreaded, object-oriented language structures, required by VR operating shells for simulation and immersive visualization, are entirely absent in the current HPF. In turn, the current VR models are still focused on human-machine interface components and they don’t address at all the HPC components of televirtuality systems. Dataflow based visualization models such as AVS or Explorer recently gained some popularity in the research community as convenient tools to narrow the gap between front- and back-ends of HPC applications. In such models, parametrized and encapsulated HPC modules are linked together into the dataflow networks, communicating under control of the AVS kernel by passing data objects such as fields, geometries, colormaps etc. Such techniques are suitable for scientific visualization, based on time-ordered sequences of mappers and filters to transform computational fields into geometries and images, but they are less natFaigle, Fox, Furmanski, Haupt & Niemiec
ural for the asynchronous, mutithreaded computing environments of VR where both the feedforward and feedback communication pathways are required. The broader is the computational domain to be integrated, the more powerful integration tools are required. When integrating software modules towards global computing environments, we will need to cope with a variety of languages, communication protocols, operating environments and user interface metaphors. The ultimate integration tool must therefore contain an internal, self-consistent image of all these constructs. It is much too early for an ultimate ansatz for such a model as various component modules are not yet fully stabilized. Instead, we adopt here a more flexible development and experimentation strategy, referred to in various programming contexts as intermediate representation, infrastructure software, or virtual machine. The MOVIE (Multitasking Object-oriented Visual Interactive Environment) [Furm92a][FFHNPS92] system at NPAC can be viewed as a prototype model of this type. It is based on a multi-server network of multithreaded interpreters of a high-level object-oriented programming and communication language. Interfaces with individual computational domains are constructed by enhancing and customizing suitable components of such multi-faceted environment. The link with regular HPC is established by developing a family of data parallel objects and operators. The link with VR is provided by the multithreading server dynamics, combined with suitable scriptable interfaces to GUIs and renderers. Language passing communication model admits a variety of distributed computing paradigms. Finally, the interpretive programming environment facilitates rapid prototyping and, when combined with preemptive multithreading, it allows for run-time experimentation with application modules and system integration models. Our current focus in MOVIE is on developing the HPF interpreter which we view as an important step towards large scale system integration discussed above. This effort builds on NPAC’s expertise in HPF language and compiler development and on the existing software resources of HPF and MOVIE. We are also monitoring developments in VR technologies and we develop suitable system support, to be used in the next step for integrating VR with HPC within the planned VR lab at NPAC. This paper is organized as follows. We start with the overview of the MOVIE system in Sec. 2, followed by a discussion of the HPF interpreter effort in Sec. 3 and VR research in Sec. 4. Sec. 5 illustrates all these modules in action within the planned televirtuality application. Finally, the current implementation status is summarized in Sec. 6. 2.
2
The MOVIE System The MOVIE System is a network of MOVIE servers. NPAC, Syracuse University
Software Integration Towards Global Computing
High Performance Fortran Interpreter
A MOVIE Server is an interpreter of MovieScript. MovieScript is a high level object-oriented programming language derived from PostScript. PostScript is embedded in the larger language model of MovieScript. This includes new types and operators as well as syntax extension towards the C++-style object-oriented model with dynamic binding and multiple inheritance. MOVIE Server is based on custom made high performance MovieScript interpreter. Some design concepts of MovieScript are inherited from the NeWS [GRA89] model, developed by Sun. C-shell based CASE tools are constructed for automated server language extension. MOVIE 1.0, to be released in ’93, will offer uniform MovieScript interface to all major components of the Open Systems software such as X/Motif/OpenLook, DPS/NeWS, PEX/GL, UNIX socket library based networking and Fortran90–style index-free matrix algebra. Subsequent releases will build on top of these standards and extend the model by more advanced modules such as database management, expert systems and virtual reality. The language extensibility model is based on the concept of inheritance forest which allows to enlarge both the functional and object-oriented components of MovieScript, both in the system and application sector, both at the compiled and interpreted level. The default development model for MOVIE applications is based on MovieScript programming. System integration tools are also provided which allow to incorporate ‘third party’ software into the system and to structure it as suitable language extensions. Integrated visualization model is provided, unifying 2D pixel and vector graphics, 3D graphics and GUI toolkits. Interfaces to AVS-style dataflow based visualization servers are also provided. MOVIE Server is a single C program, single UNIX process and a single X client. The server dynamics is governed by preemptive multithreading with the real-time support. Threads, which are MovieScript light-weighted processes, compute by interpreting MovieScript and communicate by sending/receiving MovieScript. Uniform model for networking and message passing is provided. Various forms of concurrency can be naturally implemented in MOVIE such as single server multitasking or multiserver networks for MIMD-parallel or heterogeneous distributed computing. Multiserver systems of multhreading language interpreters offer novel approach to parallel processing, integrating data parallel and dynamic, irregular components. Due to the system features such as rapid prototyping, extensibility, modularity and ‘in large’ programming model, MOVIE lends itself for building large modern software applications. 3.
tific and engineering applications since its introduction over three decades ago. The advent of parallel computers made, however, ordinary FORTRAN 77 or FORTRAN 90 obsolete, in the sense that codes written in these languages do not provide sufficient information to exploit the full capabilities of modern architectures. To address these problems, a new FORTRAN standard, High Performance Fortran, has been proposed [HPF92], as an extension to FORTRAN 90. It is expected that HPF compilers will be offered by all major U.S. parallel computers vendors by 1994. HPF is closely based on the research language FORTRAN D, designed and implemented by research groups at Rice and Syracuse University [FHKKKTW90]. The goal of High Performance Fortran is to define language extensions and feature selection for FORTRAN supporting data parallel programming, defined as single threaded, global name space, and loosely synchronous parallel computation for variety of architectures, from a single workstation to massively parallel MIMD computers. Parallelism in HPF is achieved by exploiting array syntax features of FORTRAN 90 supplemented by the explicitly parallel statements FORALL and INDEPENDENT DO, and a rich set of FORTRAN 90 and HPF intrinsic functions. High performance is achieved by appropriate data mappings and alignments, enforced by the programmer in terms of the HPF compiler directives (for details see [HPF92]). As a part of our research program we developed a prototype HPF compiler, FORTRAN 90D [BCFHR93], which runs on a iPSC/860, an nCUBE2 and a network of SUN workstations. Equipped with the compiler we started the validation process of HPF language [CFHR92] on the basis of HPF benchmark suite being developed at Syracuse [Haupt92]. It is our experience that HPF seems to be a very convenient and efficient tool for data programming for many applications, in particular, for synchronous and loosely synchronous regular problems. We have estimated that roughly half of the current large scale calculations fall into that category. Our research program evolves now towards the design and development of new language extensions to address irregular problems, like those inherent to some of Grand Challenge applications, which are not easily expressible in HPF. In collaboration with Rice and University of Maryland at College Park we are developing run-time support for irregular communications, PARTI [PSDKC92], automatic partitioners for irregular problems and strategy for incorporating these in a compiler. This includes development of new data structures targeted toward problems in which highly structured computations on a set of subdomains are coupled in an irregular manner.
High Performance Fortran Interpreter Fortran has been the language of choice for scien-
Faigle, Fox, Furmanski, Haupt & Niemiec
In parallel with the HPF language and compiler exten3
NPAC, Syracuse University
Software Integration Towards Global Computing
High Performance Fortran Interpreter
sion program, we are developing the MOVIE based HPF interpreter (HPFI). HPF compiler translates the HPF source to the node Fortran77 + message passing code which is subsequently translated to the node machine code by the node compiler. HPF interpreter translates the HPF script to the node MovieScript + MovieScript passing, which is immediately interpreted by the node MOVIE server. Global array constructs of HPF are expressed in terms of suitable node objects of MovieScript such as field (n-dimensional array) and grid (n-dimensional template). Array sections are expressed in terms of suitable (field, grid) pairs. Fields and grids form a closed algebra expressed in terms of set-theoretical, boolean and arithmetic operators of MovieScript. This algebra includes the APL- or Fortran90–style index-free matrix algebra.
the capabilities of advanced runtime support. One of the notable features of this type, natural in MOVIE and often difficult to implement in compiled model is thread mobility. Indeed, there is a one-to-one correspondence between code and data in MOVIE, i.e. between any MovieScript object or, more general, any internal state of a MOVIE server, and a MovieScript code which creates such configuration. In consequence, threads can be easily moved between nodes by converting data to code at the sender side, sending the code and converting it back to data at the receiver side. As a first trial implementation of these concepts, we have installed during this summer a mesh of MOVIE servers on the nCUBE2 at NPAC and we constructed the VERTEX based MovieScript passing support. The communication performance loss due to the interpreter overhead is visible only in the startup time which is larger by a factor of 2 than the VERTEX latency. These differences, as well as interpreter penalties in the computation sector are typically negligible in the data parallel (array) sector, and hence the asymptotic performance figures in the large node limit are identical for data parallel compilers and interpreters. The programmer’s interface in the discussed nCUBE2 implementation was given by the usual MovieScript interpreter prompt as in the workstation version, but now referring either to an interactively selected node or group of nodes, or to the whole machine. The metaphor of ‘live processing mesh’, responding interactively to developer’s command line queries is extremely useful in code prototyping and testing tasks such as optimizing decompositions and communications, deadlock detection, intermediate timing etc. As a natural next layer, the graphical user-friendly tools for HPC software development will be constructed in terms of the MovieScript interfaces to the GUI toolkits.
It is convenient to think of MovieScript layer of HPFI as of portable assembler for a virtual multicomputer, constructed as a mesh of MOVIE server ’chips’. In consequence, this layer is both source language- and machineindependent. In this sense, our approach shares common features with recent efforts of factorizing the front- and back-ends of compiler software in terms of a standardized, universal intermediate layer. Recent examples include VCODE [BCHSZ92] intermediate layer for the NESL parallel language, YR (Yale Intermediate Representation) [ChCo92] for parallel Fortran compilers, or the ANDF (Architecture Neutral Distribution Format) promoted by OSF [Macr92] for generic compilers. Machine independence implies that porting HPFI amounts simply to porting the MOVIE server, which is written in portable C and hence, the whole operation amounts simply to recompiling the server once for each new architecture. This applies both to multicomputers and heterogeneous networks since the MovieScript based message passing (which we also call MovieScript passing to stress the language rather than packet based communication) is ASCII based and hence insensitive to architectural differences such as byte ordering etc. Source language independence implies that the field/grid algebra of MovieScript can be equally well employed for developing interpreters of other data parallel languages such as versions of concurrent C++ or *Lisp.
Our current major effort is to build the full interpretive HPF front-end on top of the MovieScript layer discussed above. This amounts to developing HPF parser with the rule action codes expressed in MovieScript and to providing full HPF support for data decompositions. This program is pursued in parallel with the HPF compiler development discussed before. The ultimate goal is to merge compiler and interpreter software resources and to offer the integrated programmer’s environment, with the interpretive mode for prototyping and with the compiled mode for production.
The software architecture of HPFI on a mesh of processors is represented by a mesh of MOVIE servers. HPF script is translated in the SIMD-style from the host “sequencer” to the node MovieScript “instruction set” and handled by a single identical thread in each node. Other threads can be also spawned, either in a regular mode as independent computations in overlay, or in an asynchronous mode, e.g. as point-like queries to inspect status (load balance, memory usage, local variables etc.) of individual nodes or as independent irregular computations. In consequence, the multithreaded scriptable layer of MovieScript provides Faigle, Fox, Furmanski, Haupt & Niemiec
As an independent thrust, we view the multi-server based intermediate layer of HPFI as a convenient experimentation platform for the HPF language extensions towards dynamic, irregular, multithreaded patterns typical for heterogeneous distributed computing. To the end of this section, we expose the system functionality in this area and we discuss some examples of such extension process. MovieScript passing assumes some synchronicity be4
NPAC, Syracuse University
Software Integration Towards Global Computing
Virtual Reality
tween sender/receiver and is therefore a natural communication mechanism for regular or loosely synchronous data parallel sector of HPF. For asynchronous problems, a more convenient solution is provided in terms of NeWS style event objects. Events are created, identified by a key object, posted and consumed. Threads express interests in selected events, identified by a suitable match of a sender and receiver key. Posted events are delivered to interested threads, queued, and then handled and consumed by the thread code. A thread can either block, waiting for a specific event, or it can poll the event queue without relinquishing control. Another high level communication/coordination mechanism is proposed by Linda [Gele85]. This model can be viewed as a suitable customization and generalization of the event mechanism discussed above. Threads communicate by creating and posting variable length data structures called ‘tuples’, maintained in the globally shared ‘tuple space’. In a similar way as NeWS events, tuples are identified by suitable pattern matching, with the tuple key defined by the tuple content. Tuple can be either consumed by an interested thread or simply copied with the original retained in the tuple space. The conceptual difference between events and tuples is that the former are typically transient and small and the latter can be more persistent and large, and hence implemented as distributed data structures. The question of ‘the best’ communication model for distributed computing is often raised recently in the context of currently popular models such as Express [Para88], PVM [Sund90] or Linda [Gele85]. In our opinion, all these communication mechanisms are useful in suitable configurations and large applications will typically find a natural place for all of these models. For this reason, we are developing layered communication structure in MovieScript, with growing level of abstraction. The lowermost system layer is similar to ’interpreted PVM or Express’ with MovieScript objects as messages, followed by the lowermost programmer’s layer given by MovieScript passing mechanism, followed by NeWS-like events, followed by Linda-like tuples etc. A single thread can be involved in all of these and probably many other communication activities. A good real world example is a conference participant, who chooses to interact with others by message passing (paper or card exchange), language passing (discussions), queued events (hotel phone messages) or tuples (conference blackboard messages), depending on the nature of particular communication. In the context of HPFI, some of these asynchronous communication mechanisms will be used in suitable implementation layers. For example, events are natural to implement dynamic load balancing or thread mobility. Some other constructs, such as large distributed tuples can be perhaps included as HPF extension towards dynamic database management. As discussed before, the interpretive develFaigle, Fox, Furmanski, Haupt & Niemiec
opment platform of HPFI will facilitate such experiments with the language design. 4.
Virtual Reality Another major component of the MOVIE system is user interface. It includes MovieScript interfaces to Open Systems standards in the area of windowing and GUIs such as X, Motif, PostScript and 3D protocols: PHIGS/PEX and OpenGL. Scriptable interface to Motif allows for rapid prototyping of graphical front-ends and smooth coupling between the user interface code and the computational backends of large applications. This has been tested in GIS-type applications for the Army which require both sophisticated windowing and HPC to experiment with and integrate various image processing and neural network algorithms. Currently, we are developing a MovieScript based protocol for 3D graphics and we explore current systems and emerging standard candidates in the area of Virtual Reality. This work is expected to gain momentum in ’93, when we plan to initiate the VR lab at NPAC, focused on integrating virtual reality into HPC. We plan to use MOVIE in this context both as a software integration platform to couple current VR operating shells with HPC modules such as HPFI discussed before, and as a software development platform, to extend the current MOVIE by the Open Systems standards based VR capabilities. Our work on implementing VR in MOVIE is scheduled in several stages. First, we are implementing a three dimensional graphics shell. This shell provides types and operators to allow the creation and manipulation of all of the standard low-level types of 3D objects, such as lines, polygons, spheres, cones, lights, etc. Interpreted access is provided to all of the objects. This allows programmers and designers to directly manipulate objects if they wish, even while an application is running. The 3D model in MovieScript is designed to run on top of any of the current 3D standards, such as PHIGS, PEX, GL or OpenGL, or any future standard. On top of this standard object level are groups of objects, implemented as ‘scene dictionaries’. Each dictionary contains named instances of objects. These are nested to provide for complex objects. For example, four legs and a top is a table. A table and four chairs and two candles is a dining set, etc. Finally, we will have one more level, which is an abstraction of the scene concept into a world space. This will allow us to create connections between multiple scenes. Each graphics object is represented as a suitable MovieScript code which creates this object. A PostScript programming philosophy, allowing for smooth interplay of parametric and functional elements of computer graphics, is particularly useful here and it extends in a natural way to 5
NPAC, Syracuse University
Software Integration Towards Global Computing
Virtual Reality
the 3D domain. The collection of MovieScript routines for a family of objects and scenes forming a world is typically stored on disks and accessed dynamically in the run-time according to current needs of a VR simulation. In this sense, one can view this sector of MovieScript as providing smooth interface with the CAD/CAM domain and with the high-level language interfaces to object-oriented databases [BaMa88]. Autodesk, Inc., the CAD leader, provided also recently the initial intellectual burst in the area of VR software [Wals92]. Another major effort towards industry standard VR operating environment is pursued at HITLab [Furn92][BrJa92]. We are monitoring these developments and we observed that there are commonalities between these emerging VR operating shells and the MOVIE system [Furm91]. The concept of interpreted multithreaded development environment, based on extensible high-level language protocol, is common to these and other VR systems. For example, Trix at Autodesk is based on extended FORTH and VEOS at HITLab uses Xlisp. Another advanced environment with similar characteristics is SuperGlue [HiRa92] at NASA Ames, based on Scheme [ASuSu85] dialect of Lisp. Our choice of PostScript as a base language platform for MovieScript design was motivated by the attractive device independent graphics model, optimal communication dynamics and appealing ’virtual machine’ metaphor of PostScript. In fact, FORTH and Lisp can be viewed as direct ancestors of PostScript [ASI87]. Historically, FORTH evolved towards real-time control and robotics applications, Lisp towards AI applications and PostScript towards graphics. All these components are now being integrated within the VR operating environments. Currently most popular communication model for distributed VR is given by versions of Linda coordination language. For example, VEOS at HITLab uses shared ’grouple space’ to communicate between VEOS entities. In more general sense, Linda-type paradigm provides a natural overall mechanism to implement the concept of shared, multiuser Virtual Worlds. We expect other high-level communication mechanisms to be also useful in dynamic heterogeneous environments. For example, CNRI develops a concept of knowbots (knowledge robots) [Cerf91], represented by high-level scripts/queries which propagate across the net, multiply, branch etc. in search of required information. Another major family of advanced simulation systems is associated with the SIMNET technology, developed by DARPA for military purposes in mid ’80. SIMNET is now converted to virtual environments [Zyda92], a new standard for distributed interactive simulation environments (DIS) is being drafted, and the major follow-on program CCTT (Close Combat Tactical Trainers) is started by DoD in the area of synthetic environments [DSTS92]. Faigle, Fox, Furmanski, Haupt & Niemiec
We intend to experiment with these and other VR operating shells and communication models within the planned VR Lab at NPAC. Our two-prong strategy is to both install at NPAC and evaluate the promising candidates for VR standards, and to continue with the bottom-up development of intrinsic MovieScript functionalities, required for developing the MOVIE based VR operating environment. The design similarities between various VR systems and MOVIE will allow for constructive interplay between these two approaches. A distinctive feature of our approach to VR is the integration with HPC, addressed in the initial stage of the VR software program [Furm92b]. This will allow us to impose design consistency on various modules of the overall environment, such as HPFI discussed in Sec. 3, various MovieScript based communication models, and the VR front-ends. We visited recently several VR labs and companies such as Autodesk, Sense8, HITLab and Sarnoff, and we attended VR conferences such Meckler’s 3rd VR’92 in San Jose, HITLab’s 2nd Industry Symposium in Seattle or EFDPMA’s 3rd VR Conference in Washington DC. VR is still an ’industry in embryo’, with the R&D efforts pursued mainly by visionary motivated individuals but one also observes increasing involvement of large corporations such as Boeing, IBM or EDS. Major new developments are expected in coming years, driven by new high resolution display technologies, HDTV and consumer electronics. The specific integration patterns of this domain with federal initiatives such as NREN and HPCCI towards global computing based televirtuality are yet to be determined. We see modern software integration techniques as crucial component of this process. We discussed various high-level interpreted language domains such as CAD, SIMNET or AI and we consider this software development and integration technology as most promising for large simulation and information processing environments to come. Rather than expecting any of these paradigms to take over and set global standards in the near term, we predict a domain language based scenario, in which individual geographic and/or topical areas develop customized environments, including scriptable language translation capabilities to communicate with other regions. Our current efforts in MOVIE are in the spirit of such approach. The HPFI interface is being prepared for scientific/engineering computing domain on top of MovieScript layer, whereas the MovieScript protocol per se is expected to be more suitable for dynamic programming such as prototyping user interfaces and communication patterns for distributed computing. Applicability of MovieScript for device independent description of ’canned’ virtual worlds is to be explored and confronted with other proposals, expected in this area. MovieScript based translators to other language models such as Lisp, concurrent C++ 6
NPAC, Syracuse University
Software Integration Towards Global Computing
Implementation Status
downtown Syracuse and further with the Supercomputing Corridor line, connecting Cornell University and Rome Laboratories. In turn, Supercomputing Corridor is expected to be linked to the Aurora gigabit testbed within the NREN program,
and SIMNET domain are under consideration. 5.
Test Case: Grand Challenges as Virtual Worlds We summarize here the concepts, discussed in this paper, in terms of the specific pilot project, currently planned at NPAC, aimed at evaluating televirtuality for K-12 education. We intend to re-use in this project some selected Grand Challenges codes out of the existing and forthcoming collection of the HPCCI projects. Some of these codes are already developed in CM-Fortran, which is a subset of HPF, and we expect HPF to become soon the major development platform for new advanced applications in scientific computing. Many Grand Challenges have substantial educational potential, such as for example weather forecast, climate modeling or human anatomy. Still, availability of these codes for the K-12 education is practically non-existent due to complex translation process, required to convert these advanced research environments to the educational purposes, as well as due to physical separation between schools and supercomputer centers. The latter distance is expected to be shortened by broadband networking. The televirtuality paradigm would be completed by the forthcoming generation of consumer VR devices, which are primarily targeted at the home entertainment market, and which would find an attractive double-use for educational purposes within the ’edutainment’ concept. We intend to use HPFI to restructure the Grand Challenge codes to the form of suitable dynamic, interactive and immersive Virtual Worlds. Fortran codes in scientific computing are often written in a traditional singlethreaded fashion. In the context of interactive computing environment, such codes need to be rearranged and chopped into small chunks, corresponding to appropriate callback or notification functions, responding to individual sensors and/or threads of control. Often, some additional interaction/communication code needs to be constructed and tested in the context of the whole simulation. All such operations are very tedious and time consuming in the conventional compiled environment, and can be substantially facilitated in the interpretive model. In other words, we intend to use HPFI in this project as an interactive editor/formatter, operating on large HPF codes. The televirtuality environment for the K-12 project at NPAC will involve the following components:
consumer VR products, currently developed by the NY based VR company AGE, Inc. AGE is NPAC’s industrial partner within the industrial outreach program NYS ACTION. These new low cost VR devices are expected to reach the home entertainment market by the end of ’93 in the form of Nintendo-like packages with high quality head mounted displays. NPAC expects to get early access to prototypes and to install test sites in selected local schools, participating in the project. We expect to interface with the headset either directly from the computer or from CD-ROM/VHS tape using MPEG compressed data. The goal of the project is to evaluate components of the televirtuality technology, listed above, and to explore the educational potential of VR. This will include interactions with school representatives, teachers and students, and prototyping and testing appropriate interfaces. We adopt the overall framework of “Virtual School” and we focus within this project on implementing a trial set of “Virtual Classes/Courses”, corresponding to selected Grand Challenge codes. User interface layers of MOVIE such as GUIs and binders to VR front-ends will be used in this project to experiment with various design concepts and to provide connectivity with the computational engine, given by Grand Challenge codes within the HPFI environment. 6.
Implementation Status We summarize here the current technical implementation status of various software modules discussed above. MOVIE system is operational at NPAC and includes currently base interpreter, APL-style field/grid algebra discussed in Sec.3, support for heterogeneous networking, and GUI interfaces to X, Motif, Display PostScript, NeWS, AVS and PHIGS. MOVIE server runs on DEC and SUN workstations and on the nCUBE2 multicomputer. Interfaces to other Open Systems GUI models and ports to other hardware platforms are in progress. The first external release MOVIE 1.0 is expected by mid ’93. The work on HPF parser to translate HPF script down to MovieScript within the HPFI model discussed in Sec. 3 is starting now in collaboration with the HPF compiler group at NPAC. A prototype of NPAC’s HPF compiler has been recently demonstrated at the Supercomputing ’92. We expect the first performance results for the MOVIE based HPFI to be available in April and included in the camera-ready copy of this document. At the time of this conference (June ’93),
NPAC parallel systems such as CM-5, DECmpp, Intel Touchstone and nCUBE2 with parallel Oracle, workstation clusters, FDDI and UltraNet LANs, and facilities of the planned Virtual Reality lab, OC3 45Mbit/sec line connecting NPAC facilities with the Museum of Science and Technology (MOST) in Faigle, Fox, Furmanski, Haupt & Niemiec
7
NPAC, Syracuse University
Software Integration Towards Global Computing
Implementation Status
we expect the prototype version of HPFI to be operational and demonstrable.
7.
[DSTS92] Defense Science and Technology Strategy, Technical Report by Director of Defense Research and Engineering, July 1992. [Furm91] Furmanski, W., “Report from the Virtual Reality Tour”, Syracuse Center for Computational Science, Technical Report, 1991.
References
[Furm92a] Furmanski, W., “MOVIE – Multitasking Objectoriented Visual Interactive Environment”, in Fox, G.C., Messina, P. and Williams, R., editors, Parallel Computing Works, Morgan and Kaufman, 1992 (in preparation).
[ASuSu85] Abelson, H., Sussman, G., Sussman, J., Structure and Interpretation of Computer Programs, MIT Press 1985. [ASI87] Adobe Systems, Inc., PostScript Language Reference Manual, Addison-Wesley, 1987.
[Furm92b] Furmanski, W., “Supercomputing and Virtual Reality”, paper presented at the Meckler Conference Virtual Reality ’92, San Jose, CA, Sept 23–25, 1992.
[Barr92] Barrett, T., “Information Places: Implications and Applications”, presented at the 3rd EFDPMA VR Conference, Washington DC, Dec 1–2, 1992.
[Furn92] Furness, T.A., “Overview and HITlab Program”, talk resented at the 2nd Indsutry Symposium on Virtual Worlds Technology, Seattle, WA, Oct 23–25, 1992.
[BaMa88] Bancilhon, F. and Maier, D., “Multilanguage Object-Oriented Systems: New Answer to Old Database Problems?”, in Fuchi, K. and Kott, L., editors, Future Generation Computer II, North Holland, 1988.
[FFHNPS92] Faigle, C., Furmanski, W., Haupt, T., Niemiec, J., Podgorny, M. and Simoni, D., “MOVIE Model for Open Systems based High Performance Distributed Computing”, in Proceedings of the First International Symposium on High Performance Distributed Computing, HPDC-1 Sept 9–10, 1992, Syracuse, NY, IEEE Computer Society Press.
[BrJa92] Bricken, W. and Jacobson, L., “Virtual Environment Operating System”, in AI Expert: Virtual Reality Special Report, July 1992, [BCFHR93] Bozkus, Z., Choudhary, A., Fox, G..C., Haupt, T., Ranka, S.,“Distributions in F90D” and “Forall in F90D”, SCCS TR93 (in preparation)
[FHKKKTW90] Fox, G.C., Hiranadani, S., Kennedy, K., Koelbel, Ch., Kremer, U., Chau-Wen Tseng and MinYou Wu, “Fortran D Language Specification”, CRPC TR90–141, Rice University, and SCCS/42C, Syracuse University, 1990.
[BCHSZ92] Blelloch, G.E., Chatterjee S., Hardwick, J., Sipelstein, J. and Zagha, M., “Implementation of Portable Nested Data-parallel Language”, CMU Technical Report, October 1992.
[Gele85] Gelernter, D., “Generative communication in Linda”, ACM Trans. on Programming Languages and Systems, 7(1):80–112, 1985.
[Cerf92] Cerf, V.G., “Networks”, in “Communications, Computers and Networks: How to Work, Play and Thrive in Cyberspace”, special issue of Scientific American, September 1991.
[Gore91] Gore, A., “Infrastructure for the Global Village”, in “Communications, Computers and Networks: How to Work, Play and Thrive in Cyberspace”, special issue of Scientific American, September 1991.
[ChCo92] Chen, M. and Covie, J., “Prototyping Fortran-90 Compilers for Massively Parallel Machines”, in proceedings of ACM SIGPLAN’92 Conference on Programming Language Design & Implementation.
[GRA89] Gosling, J., Rosenthal, D.S.H., Arden, M., The NeWS Book, Springer Verlag, 1989.
[CFHR92] Choudhary. A., Fox, G.C., Haupt, T. and Ranka, S., "Which Applications Can Use High Performance Fortran and Fortran-D: Industry Standard Data Parallel Languages?”, in proceedings of the Fith Australian Supercomputing Conference, Melbourne, Australia, Dec 7-9, 1992 (also available as Syracuse University TR SCCS360)
[Haupt92] The HPF/Fortran-90D benchmark suite and its documentation is available via anonymous ftp from minerva.npac.syr.edu. The contact person is T. Haupt (
[email protected]) [HuRa92] Hultquist, J.P.M and Raible, E.L., “SuperGlue: A Programming Environment for Scientific Visualization”, RNR Technical Report RNR-90-014, NASA Ames Research Center, Moffett Field, CA, 1992..
[CFRHKKKT90] Choudhary, A., Fox, G.C., Ranka, S., Hirandani, S., Kennedy, K., Koebel, C., Kremmer, U. and Tseng, C., "Compiling Fortran-77D and 90D for MIMD Distributed-Memory Machines", CRPC TR92-203, Rice University, and SCCS–251, Syracuse University, 1990 Faigle, Fox, Furmanski, Haupt & Niemiec
[HPF92] "High Performance Fortran Language Specification" by HPFF, Draft Version 0.4. Available via anonymous ftp from minerva.npac.edu and cs.rice.edu. To be
8
NPAC, Syracuse University
Software Integration Towards Global Computing
References
available as the Rice University Technical Report in December 92 or January 93.
C., and Choudhary, A., “A Runtime Data Mapping Scheme for Irregular Problems”, in Proceedings of Scalable High Performance Computing, Williamsburg, VA, April 27–29, 1992, IEEE Computer Society Press (also TR SCCS-356, Syracuse University, 1992).
[Jaco92] Jacobson, R., “Televirtuality: Status of Projects Around the World”, talk presented at the EFDPMA Conference on Virtual Reality, Washington, DC, June 1–2, 1992.
[ScAm91] “Communications, Computers and Networks: How to Work, Play and Thrive in Cyberspace”, special issue of Scientific American, September 1991.
[Kahn92] Kahn, R.E., Keynote Address at the 2nd Industry Symposium on Virtual Worlds Technology, HITLab, Seattle, WA, Oct 1992.
[Stop92] Stoppi, J.U.L, “Televirtual Environments: Concept, Applications, and Implications”, in Sandra K. Helsel, ed., Virtual Reality Report, Meckler, Sept 1992.
[Macr92] Macrakis, S., “The Structure of ANDF: Principles and Examples”, Open Software Foundation, Technical Paper, January 1992.
[Sund90] Sunderam, V.S., “PVM: A framework for parallel distributed computing”, Concurrency: Practice and Experience, 2(4), 315–339, 1990.
[MIS91] Matrix Information services, Inc., Virtual Reality – The Next Revolution in Computer/Human Interface, MIS, 1991.
[Wals92] Walser, R., “A De-Facto Anti-Standard for Cyberspace”, talk presented at the Meckler Conference Virtual Reality ’92, San Jose, CA, Sept 23–25, 1992.
[Para88] Parasoft Corporation, Express Reference Manuals, 1988.
[Zyda92] Zyda, M., “The Software Required For the Computer Generation of Virtual Environments”, talk presented at the 3rd EFDPMA Conference on Virtual Reality, Washington, DC, Dec 1–2, 1992.
[PCKW89] Parsaye, K., Chignell, M., Khoshafian, S. and Wong, H., Intelligent Databases, Wiley, 1989. [PSDKC92] Ponnusamy, R., Saltz, J., Das, R., Koebel,
Faigle, Fox, Furmanski, Haupt & Niemiec
9
NPAC, Syracuse University
