INTERNET-BASED COLLABORATIVE SYSTEM DESIGN USING
MOSCITO
A. Schneider E. Ivask
Fraunhofer Institute for Integrated Circuits Tallinn Technical University Branch Lab EAS Dresden Department of Computer Engineering Zeunerstraße 38, 01069 Dresden, Germany Raja 15, 12618 Tallinn, Estonia
[email protected] [email protected]
Abstract. This paper introduces a software architecture which can help that
Internet-based collaboration in the field of system design becomes reality. Today many powerful tools for simulation, synthesis, test, and optimization are availa-ble. But most of them can only work as stand-alone tool on a certain platform. With MOSCITO these design tools can be encapsulated and coupled via Inter-net. Design engineers can remotely use the needed programs like a service and partners locating in different geographical sites can perform collaborative experiments over Internet. The author describes basic ideas and the imple-mented infrastructure of MOSCITO and discusses first practical experiences.
Keywords. Internet-based design, simulation, optimization, test, security,
firewall-protection
1 Motivation
Starting from the idea to connect tools via the Internet to form an appropriate workflow for solving dedicated design problems the MOSCITO system at Fraunhofer IIS was developed and implemented [3].
The MOSCITO system works as an Internet-based multi-agent system which can be control-led and observed by the user's front end program – the MOSCITO Desktop. Over the last years several approaches for coupling tools and providing services via Internet were devel-oped. Powerful middleware such as CORBA, Java RMI, COM/DCOM or HLA is available today for implementing such distributed infrastructures. MOSCITO is mainly based on the general ideas of these approaches but it uses a very small, pure Java-based implementation. Some reasons for this design decision are:
• CORBA is very complex. It supports components which can be implemented in different programming languages. In MOSCITO this feature is not necessary because each tool is encapsulated in a Java wrapper class - the MOSCITO Agent.
• COM/DCOM is available on Microsoft platforms only. MOSCITO is needed at least on Solaris, Linux and Windows systems.
• Main focus of HLA is coupling of simulators. MOSCITO isn't restricted to this application area.
• In some systems only a white-box integration of tools is possible. MOSCITO Agent inter-face is targeted to support black-box integration. So also commercial tools can be encapsu-lated with low effort.
• Systems like [2] are based on very fine-grained, powerful workflow concepts. MOSCITO uses very simple, dataflow-based workflows which are controlled by the MOSCITO
Agents themselves.
The main emphasis in the MOSCITO tool integration was put on the following aspects: • Encapsulation of design tools and adaptation of the tool-specific control and data input/
output to the MOSCITO framework
• Communication between the tools for data exchange to support distributed, Internet-based work.
• Uniform graphical user front-end program for the configuration of the tools, the control of the whole workflow and the visualization of result data.
Moreover, an important goal is to provide the functionality of a tool to a potential user as a service in a local area network (LAN). This approach is similar to the Application Service Provider (ASP) idea or the recent approach of Web Services.
2 MOSCITO Architecture
In the present system several tools have been integrated in MOSCITO: simulators, optimiza-tion programs, test pattern generators, translators etc. All these tools can act as MOSCITO
Agents and each of them provides a service. The user are empowered to combine all the
services to a problem-specific workflow. That means, the needed tools have not to be in-stalled on the users local computer.
The MOSCITO framework was implemented in JAVA and can run on different comput-ing platforms. The only prerequisite is an installed Java Virtual Machine. At the moment MOSCITO is used on SUN workstation (Solaris) and on PCs (Microsoft Windows and LINUX).
User’s desktop Internet / LAN Design tools running on remote servers
Figure 1: MOSCITO allows a designer to use tools over Internet.
2.1 Software architecture
MOSCITO consists of three software layers: kernel layer, interface layer, and user exten-sions. The kernel provides functionality for basic object and data management, file handling, XML processing, and communication. Due to the fact that MOSCITO is an open system a special interface layer provides programming interfaces for integration of new tools, new workflows and appropriate viewers such as for diagrams, plain text and images. Each inter-face is represented by a Java class which contains the basic functionality. The user only needs to extend this class and can implement its own extension. A large number of templates and example implementations helps the user to integrate a new tool or workflow in less than one or two days.
2.2 Tool encapsulation
For the integration of tools with MOSCITO a sophisticated agent interface was introduced. A tool is embedded into a MOSCITO agent for:
• adapting the input data to the embedded tool,
• converting the tool-specific data (simulation results, logfiles, test vectors),
• mapping the control information to the embedded tool and the transfer and conversion of status information (warning and error messages) to be submitted to the user.
For embedding programs into a MOSCITO agent there are three ways:
• Integration of the entire program: the software has to be runnable as batch job without any user interactions. In this way the integration of many commercial tools are possible. • Embedding legacy code as library via the Java Native Interface (JNI): e.g. C, C++ or
FOR-TRAN routines can be embedded.
• Direct integration of Java-classes and applications, respectively, in particular for software written in JAVA.
Encapsulation of the tools as a MOSCITO agent guarantees a uniform interface to the frame-work. All tool-specific details are aggregated in a special agent description file. This file is necessary to create tool-specific dialogs for the configuration of the tool via the front-end program.
Figure 2: Tools available as MOSCITO agents via Internet can be coupled to workflows.
Tool A Tool B Tool C
Tool F
Tool E Tool D
2.3 Communication
The implementation of the communication between tools (agents) is based on TCP/IP-sock-ets. The tools can be executed on different computers or on different computing platforms (e.g. UNIX, Windows). Similar to tool encapsulation the data are sent as encapsulated data-grams. MOSCITO provides a flexible container class MOSCITO Datagram for data objects of different types: strings, scalars and arrays of integers, floating point numbers, ascii and bi-nary files. For data transfere between agents it is very simple to put the needed data objects in the MOSCITO Datagram container. A receiver can look in the datagram and can extract data objects as needed or can put additional result data in the container. The advantages of this solution are:
• any kind of data can be transferred between different agents;
• in tool-chain workflows data can be passed to all subsequent agents (even to agents where a direct connection doesn’t exist)
• the implementation is based on Java object serialization; MOSCITO Datagrams work plat-form-independent in the entire network.
Input
Output
Conversion Serialization MOSCITO Agent
MOSCITO Agent (Successor) MOSCITO Agent (Predecessor)
Files Control information from front-end programm Deserialization Pipes COM ...
Figure 3: A MOSCITO Agent works data-driven.
Encapsulated Tool "Netlist" "x0" MoscitoDatagram rosafilter.cir 12.5 : : "Netlist" "x0" MoscitoDatagram rosafilter.cir 12.5 : : "Netlist" "x0" MoscitoDatagram rosafilter.cir 12.5 : : "Netlist" "x0" MoscitoDatagram rosafilter.cir 12.5 : : x0=12.5 x0=12.5
Figure 4: MOSCITO Datagram encapsulates data objects for transferring them between agents.
MoscitoDatagram "Netlist" "x0" MoscitoDatagram rosafilter.cir 12.5 : :
2.4 Graphical User Interface (GUI)
MOSCITO provides two solutions for application-specific user interfaces. The first one, the
MOSCITO Desktop, is a Java application which must be installed locally on the user’s
com-puter. With this desktop GUI a user has access to all registered agents in a network. The
MO-SCITO Desktop provides the following functionality:
• The problem description including all data can be read in from a MOSCITO project file. • Workflows can be chosen from a set of predefined flows for the specific problem.
• A browser supports the choice of agents (tools) and their configuration.
• With buttons for start, pause, resume and stop the workflow can be controlled by the user. • A console window collects all messages from the running tools and allows the observation
of the proper operation or trouble shooting, respectively.
• The visualization module MOSCITO Scope supports the display of all result data (test vec-tors, statistic information).
MOSCITO also supports a pure web-based usage of remote tools and workflows. In this sce-nario only a regular, Java-enabled Web browser is required at user’s side. Small HTML pag-es with included Java applets offer specialized user interfacpag-es for certain applications. This approach is currently used for e-learning systems. A learner can perform online-experiments with remote design tools running on high performance servers.
2.5 Services for Internet-based usage
MOSCITO infrastructure implements basic services for a network-wide registration of agents and a lookup service for finding appropriate services. Furthermore, the next MOSCI-TO version will also support a secure data transfer via Internet and a tunnelling of firewalls via proxy server.
Figure 5: A MOSCITO user can control the entire workflow and observe all result data using the MOSCITO Desktop (front-end).
3 Summary
MOSCITO has been developed as an Internet-based tool integration platform. Based on the idea to connect tools via the Internet to form an appropriate workflow for solving dedicated design problems, MOSCITO provides many features supporting collaboration between ap-plications for system design (tool encapsulation and tool coupling, remote simulation).
MOSCITO software provides open interfaces for extensions. A user can integrate new tools via the agent interface. Furthermore, it is possible to set up new workflows an to extend the visualization features of MOSCITO Scope.
In the next months online-simulations will be integrated in several Web-based training modules using MOSCITO Applets as light-weight user interfaces.
4 References
[1] C-LAB: Astai(R). http://www.c-lab.de/astair
[2] Lavana, H.; Khetawat, A.; Brglez, F.; Kozminski, K.: Executable Workflows: A Paradigm for Collaborative Design on the Internet. Proc. DAC 97, Anaheim, 1997.
[3] MOSCITO: http://www.eas.iis.fhg.de/solutions/moscito
[4] Schneider, A.; Ivask, E.; Miklos, P.; Raik, J.; Diener, K.-H.; Ubar, R.; Cibáková, T.; Gramatová, E.: Internet-based Collaborative Test Generation with MOSCITO. DATE’02, Paris, March 4-8, 2002, 221-226
[5] Schneider, A.; Diener, K.-H.; Elst, G.; Ivask, E.; Raik, J.; Ubar, R.: Internet-based testability driven test generation in virtual environment MOSCITO. Proc. International Workshop on IP-Based SoC Design, Grenoble, France, October 30-31, 2002
[6] Schneider, A.; Diener, K.-H.; Ivask, E.; Ubar, R.; Gramatova, E.; Hollstein, T.; Kuzmicz, W. Peng, Z.: Integrated Design and Test Generation Under Internet Based Environment MOSCITO. EUROMICRO Symp. on Digital System Design, Dortmund, Germany, September 4-6, 2003
[7] Schneider, P.; Schneider, A.; Bastian, J.; Reitz, S.; Schwarz, P.: MOSCITO – a program system for MEMS optimization. Symp. "Design, Test, Integration and Packaging of MEMS/MOEMS", Cannes, Frankreich, May 5-8, 2002, 248-257
Figure 6: Online-simulation of Chua’s oscillator using a MOSCITO applet.
A Learner can configure model parameters.
Simulation results are shown directly in the browser. The user can zoom in to see more details.
