SEW 2.0: The System Engineer's Workbench

SEW is a distributed real-time analysis tool intended to assist academic researchers in algorithm development and teaching. It has at its roots a generalized modeling framework for distributed computing systems, and supports most known real-time analysis algorithms. Currently, only a few algorithms are implemented, but others can be added readily.

SEW has its roots in research into real-time scheduling analysis performed at Carnegie Mellon University. Several variations of a scheduling analysis tool have been made over the years, starting with a single-resource analysis tool implementing Rate Monotonic Analysis, which then grew into distributed computing analysis tools. SEW 2.0 represents the first public release of these tools.

This page serves as a source for news, developments, and obtaining code, and should be updated frequently.

This page has been viewed times since July 21, 1999.

Several examples of SEW windows appear on this page. For more detail, see the SEW Manual.

An example target-platform model, showing the elements that model a PC running VxWorks.

Introduction

The System Engineering Workbench (SEW) is an analysis tool that implements a formal framework for describing real-time computing systems. This formal framework enables the system designer to design and subsequently analyze a large-scale, distributed, heterogeneous real-time system to ensure that all application timing requirements (both distributed and single-resource requirements) are met.

Features:

Hierarchical architecture and target-platform models.
Based on years of research into modeling impacts of actual systems on real-time analysis.
Separates application from target-platform at architecture and component levels.
Separates application software from target-platform (OS) software.
Separates software from hardware, and provides scaling through a hardware-specific sizing function.
Graph-based description of service time, including loops and branches controlled by scenario parameters.
Statistical service time descriptions also allowed.
C++ mathematical expressions used for all model, which are evaluated at run-time.
ASCII file formats with supplied parser allow hand-generated, UI-generated, or otherwise generated input data.
Small library of common OSs (VxWorks, RT-Mach, IBM-AIX, Windows NT) with data based on measured phenomena
Small library of common communication hardware and protocols (RS-232, PCI, Ethernet).
Systems and communications hardware readily modeled through the creation of part definition files describing scheduling phenomena and hardware/software-specific attributes.

Benefits:

Price: free.
Complete source code included.
Easily extensible for your own research and algorithms.
Add your own custom hardware models or unmodeled systems.
UI based on Tcl/Tk, readily portable to your environment!
Object-oriented, fully written in C++.
Contains implementations of busy-period analysis (LSD and HKL), response-time analysis, busy-period and response-time simulations for stochastic systems, distributed pipeline scheduling, and end-to-end simulation.
Other algorithms readily added; data for algorithms found in models and should be readily accessible.
Participate in a shared global research project!

An example application architecture, showing the game controller and the audio mixing task, along with ports linking to external elements in the architecture hierarchy containing data streams.

License

SEW may be used for any purpose in either academic or commercial environments. You may modify the source code and use it in your own research or work. You are not permitted to sell anything derived from SEW code; your own enhancements are excluded from this restriction, including enhancements that are contributed to the SEW project. The SEW Project retains copyright on the SEW code, except where subsidiary libraries exclude such copyright.

Contributions back to the main source distribution are encouraged. I will maintain various releases as space permit, and I am currently maintaining a CVS repository for code development.

Intended Use

SEW is intended for two purposes: furthering academic research, and for use in teaching classes on real-time systems analysis.

In principle, everyone developing real-time analysis algorithms bases their work on the current known set of models and algorithms. However, building tools to test these algorithms is usually difficult, and so the academic world ends up with a lot of papers that have algorithm descriptions, but no ready mechanism to share implementations. Also, most researches end up "reinventing the wheel", so to speak, as everybody needs a common framework for describing real-time systems that has enough data. Too often we find good algorithms or analysis techniques, and yet cannot share them effectively due to subtle differences in assumptions, data types, what have you.

SEW provides a common framework, with a hierarchical component-based system model, a graph-based service time model, and the algorithms to convert to standard simple and complex service time models. Researches developing algorithms can use the data stored in these models without having to (1) create models, (2) create ways to get data into the models, (3) create a user-interface for testing and display (even command-line driven programs count as a user-interface, after all).

I am hoping SEW will become the standard framework for real-time analysis algorithms developed and shared among the real-time community. Deficiencies in the framework can be easily added to without having to redevelop an entire modeling methodology and system description. To this end, I encourage both researchers and students to contribute their work to SEW and submit changes and bug fixes. Through the work of many, all will prosper.

An example component model, showing looping and branching constructs (controlled by scenario parameters) as well as non-ideal scheduling costs (CEntry).

Obtaining SEW

SEW is based on the C++ Standard Template Library (STL), which is included with most C++ compilers. Other versions of the STL are available as well. SEW uses Tcl/Tk for its user interface along with the Tix widget package. SEW uses PCCTS ("The Purdue Compiler Construction Tool Set") to create its parsers, and uses the Graph Template Library to implement its underlying graph structures. Source code for PCCTS and GTL are included.

Download SEW source, version of July 21, 1999, approximately 1.5 MB

See the README file for installation directions.

You must also download Tcl/Tk 8.0.5 from Scriptics.com and Tix 4.1.0 from the TCL Consortium. This site cannot host them due to space constraints.

If you would like to be informed of updates to the SEW code, please mail me to say so, and I will add you to a list of people to be so informed. There will probably be a flurry of initial releases as more bugs are flushed out, followed by a more sedentary release rate as things settle out.

Updates and Patches are available. The latest patch is 2.0.1, dated July 24, 1999. All patches are relative to the July 21, 1999 release (2.0.0).

WARNING

SEW is alpha software at this point, and will likely crash a lot. Most of this is due to my own inabilities as a programmer, and insufficient testing. Also, some of the UI directions are misleading or incorrect. If you find that it crashes, I encourage you to find out why (probably a NULL pointer was not tested for). If you are so inclined, you may mail me to say you have found a bug, but can't fix it. If you send the files you're using, it would be a great help.

Of course, the best thing is for you to fix the bug yourself, then mail me a patch.

Please note that a lot of the menus don't do anything, as these represent intended functionality. Don't be alarmed.

System Requirements

SEW was developed under Linux using EGCS 1.1.2 (egcs-2.91.66) and libc5. It has been ported to Solaris (-DSOLARIS), and a port to Windows NT using Visual C++ is under way. Approximately 256 MB of hard drive space are needed for compiling (with debugging symbols), and 128 MB of RAM to run the debugger and SEW simultaneously. Without debugging information, 100 MB of hard drive space and 32 MB of RAM are needed.

Related Papers

No real papers on SEW 2.0 have been published, although there have been some publications on SEW 1.0 (mostly by Saurav Chatterjee, if you search through the various conference papers). My Ph.D. thesis on the entire modeling framework is available, but only through e-mail as my account is currently limited to 5 MB of data, and SEW is taking up most of that. If you're interested, mail me and I'll send a PostScript file back as an attachment.

The SEW Manual will be on-line soon, and contain both background data and interface directions.

Release History

Version 2.0.1: July 24, 1999. Includes printing and fixes a bug in "sec" expressions
Version 2.0: initial release, July 21, 1999.
Version 1.5: reworked entirely based on experiences with 1.0, initially developed on the LEDA library, then ported to STL in July of 1999.
Version 1.0: experimental prototype, ceased development in 1996.
Version 0.0: single-resource analysis too, ceased development in 1995.

Contributors

The following people have contributed time and effort to the SEW project in some form.

Dr. Kevin Bradley, CMU
Dr. Saurav Chatterjee, CMU
Jim Colquist, CMU
Dr. Dan Katcher, CMU
Dr. Kevin Kettler, CMU
Jose Madriz, CMU
Dr. John Sasinowski, CMU
Dr. Sirish Sathye, CMU
Dr. Dorothy Setliff, University of Pittsburgh
Dr. Jay K. Strosnider, CMU

File version 1.01, July 24, 1999 by K. Bradley .