|
|
General Information |
|
| |
|
The main point of this class is a large language-related
project. I envision two types of project:
- Use one of the languages discussed in the class to implement some
part of an embedded system and report on the results.
- Build a piece of software that synthesizes, analyzes, or
implements one of the languages discussed in class.
|
| |
Writeup |
The outcome of your project will be a workshop-class
paper, meaning it should be scholarly, accurate, and brief, but it
does not have to be polished. Ideally, it should be in a form
suitable for submission, but actually submitting it to a workshop or
conference is not required.
Like all academic papers, the contents of the writeup should be
your own and appropriate credit (i.e., citations) given where you have
used or adapted other's work.
|
|
|
Project Report Format |
|
| |
|
Make your project report look like a conference paper:
- Six pages maximum, including figures tables, and references.
This is a hard limit: edit text to reduce the size of your paper.
- Minimum 10 point font
- Two column
- Include, in the following order
- Abstract
- Introduction
- Related work
- One to three "meat" sections that describe your project
- Experimental results, if appropriate
- Conclusions
- References
- Cite all work you are mimicking, extending, or comparing yourself
with.
- Use a numbered style for citations, e.g.,
- [5]
- S. Edwards, T. Ma, and R. Damiano. Using a Hardware Model
Checker to Verify Software. In Proceedings of the 4th
International Conference on ASIC, Shanghai, China, October
22-25, 2001.
- [6]
- Stephen A. Edwards. Languages for Digital Embedded
Systems. Kluwer, 2000.
- [7]
- S. Edwards, L. Lavagno, E. Lee, and
A. Sangiovanni-Vincentelli. Design of embedded Systems:
Formal models, validation, and synthesis. Proceedings of
the IEEE 85(3):366-390, March, 1997.
- I prefer to receive the final report in PDF , but
Postscript will also be accepted. Let me know if you have
difficulty generating either. Project reports will be posted on
the class website for posterity unless you specifically ask me
not to.
|
|
|
Project Writeup Grading |
|
| |
|
Out of 100 points for the literature survey, 50 are specific to it:
- 40
- Summary and analysis of existing work in the field
- 10
- Plans for the implementation portion of the project
Out of 100 points for the final project writeup, 50 are specific:
- 10
- Formal modeling
- 20
- Implementation
- 20
- Innovation
The remaining 50 points for both writeups are the same:
- 10
- Description of context of research: its relevance and potential impact
- 10
- Description of objectives
- 10
- Meet page limit
- 5
- Grammar/spelling
- 5
- Format of references and in-text citations
- 5
- Identify at least three relevant, key papers
- 5
- Electronic version of the paper
|
|
|
Sample Project Proposal |
|
| |
|
I will implement a library supporting Kahn Process Networks
in Java. It will employ the scheduling algorithm due to Parks and
have facilities for detecting a deadlock condition. I will
construct the library and test it first on the small example from the
book, then look for more examples, perhaps the video decode example
described by Vissers. Although the final goal of this project will be
functional correctness rather than efficiency, I plan to measure the
scheduling/context switching overhead by statistically sampling the
Java process.
|
|
|
Domain-specific Language for Device Drivers |
|
| |
|
Chris Conway
|
| |
|
I will design a domain specific language for device drivers. The language
will be type-safe and include high-level abstractions for register I/O. I
will implement a translator for this language into C, allowing these
drivers to integrate with traditional low-level system code. Ideally, this
language will allow for the clean separation of code interacting with
hardware and code interacting with the operating system, allowing drivers
to be highly operating system independent. I will demonstrate this
language by writing a driver for a network card and few other typical PC
devices.
|
| |
 |
Literature Survey
|
| |
|
Literature Survey Presentation
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
Network Analyzer for the Sony Playstation 2 |
|
| |
|
Mayer Crystal
|
| |
|
For this project I intend to write a network analyzer for the Sony
Playstation 2 (PS2) in C. The analyzer will be written for the Linux port
available on the PS2, but will be written in a such a manner that would
allow for it to be run on any PS2 without the need for additional hardware.
That is, the code will be structured such that it executes efficiently and
maintains a small memory footprint which would allow me to implement the
entire application on a bootable PS2 8MB Memory Card. The final goal of the
project is to have a single 8MB Memory Card which contains both a bootable
Linux kernel with all the necessary device drivers as well as the network
analyzer software. Furthermore, it is my intention that the network
analyzer be more than a simple packet sniffer (i.e. tcpdump) and that it
perform useful analysis on the network traffic. The final report will
include the source code used for the analyzer as well as a discussion of the
general issues involved with network analysis, the specific issues
encountered when developing the application for the PS2 embedded platform,
and the output generated by the running program.
|
| |
|
Literature Survey
|
| |
|
Literature Survey Presentation
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
XML-aware embedded packet classifier
|
|
| |
|
Phil Gross
|
| |
|
I will create an XML-aware embedded packet classifier. Given an
incoming IP packet containing XML information, and a set of filters, it
will try to determine the matching subset of the filters within hard
time limits. Goals include:
a) getting something that works
b) getting something that works really fast
c) precisely characterizing the bounds on number and complexity of
messages and filters to achieve particular timing constraints
d) having it work on real hardware, hopefully the ARM-based Intel
IXP1200 Network Processors over in the EE department
e) doing some kind of formal analysis of the real-time characteristics
of the system.
|
| |
|
Literature Survey
|
|
|
Asynchronous Hardware in Software
|
|
| |
|
Michael Halas / Vimal Kapadia
|
| |
|
There are many complications in dealing with communications between
distributed systems. We will be taking some of the ideas from the
asynchronous circuits community, and applying those concepts to the
distributed software world. An example of this would be Sutherlands work
on "Micropipelines"
which uses transitions in signals as an event to
indicate a transaction. We will be comparing the relative merits and
pitfalls of using the async technique(s) vs existing distributed
systems techniques.'
|
| |
|
Literature Survey
|
| |
|
Final Report
|
| |
 |
Final Report Presentation
|
|
|
Bowling Tournament Scorekeeper
|
|
| |
|
Inga Kuznetsova
|
| |
|
I will create a program for keeping track of a bowling tournament. It
will have the capability to keep track of who went on to the next round as
well as who dropped out because of losing. Also, if the same people are
in several brackets, it will make sure that they dont play each other
every time. As for the hardware specs
I will try to make it as simple as
possible. That way
it can be run from any pc or notebook.'
|
|
|
Protocol Design For Code Exchange in Survivable Embedded Systems With a
Common Virtual Machine
|
|
| |
|
Michael E. Locasto
|
| |
|
I plan to design a protocol that allows code written for a common VM to
be moved from a central code "Factory" to set of selected nodes in the
network. The code will be married (specialized and configured) to
state from another node in the network before sending. The primary goal is
to facilitate fault tolerance in networks of embedded systems.
I will implement the protocol in Java and build a simulation using UDP
sockets. The simulation will be a PACMAN game. The nodes in the simulated
network' can transfer a running PACMAN game between them.
Future work involves allowing generic algorithmic code to be specialized
to a specific and random hardware target (not the common VM). This ability
is essential in a network of embedded devices that are highly dissimilar.'
|
| |
|
Literature Survey
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
C code generation from CDGs
|
|
| |
|
Cristian Soviani
|
| |
|
Ill study how C code can be generated from CDGs.
A CDG is a very parallel representation for a program (actually mapping
a CDG into h/w leads to a fast (v. parallel) circuit - [Edwards]).
Serializing a CDG is a challenge. Obtaining a CFG is simple if a concise
CFG exists [Simons
Ferrante]. The general problem is NP and not well
studied
also heuristics exists [Edwards].
My project will implement such technique(s). My focus will be on CDGs
obtained from esterel programs
|
| |
|
Literature Survey
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
Remote Debugging with GDB
|
|
| |
|
Min Tan
|
| |
|
In hopes of exploring the difficulties of debugging
embedded systems, Ill make GDB remotely debug an
application running on a simulator. The exact
simulator is not yet determined. The project will be
focusing on remote-debugging where the "target" does
not have adequate support(hardware, OS and interface
wise) for the debugging task. Hopefully
there's
existing simulators that can be easily adopted to work
with GDB. Details will be in the paper along with
other specific challenges and approachs to meet the them.'
|
| |
.doc |
Literature Survey
|
| |
|
Literature Survey
|
| |
|
Literature Survey Presentation
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
Esterel Virtual Machine
|
|
| |
|
Aruchunan Vaseekaran and Tamara Blain
|
| |
|
I will design a Virtual Machine which could be could be used to run
Esterel Programs in software. Esterel code is compiled into EVM codes
which are then run by an EVM. Such a program is useful for engineers who
want to build deterministic control systems utilizizing off the shelf
microprocessors at a low cost. The goal of the EVM design is to reduce
the memory footprint of target applications at the expense of execution
speed. I will design an EVM by studying different compilation techniques
for Esterel. I will then implement an EVM interpreter and compiler. I
plan to use an exising Esterel Compiler front end and work with its
intermediate representation to output EVM instructions. I will measure
its performance againt existing Esterel compilers.
|
| |
|
Literature Survey
|
| |
|
Literature Survey Presentation
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
Device Drivers
|
|
| |
|
Noel Vega
|
| |
|
For my term project in this class, I will be focusing on the design and
creation of device drivers for various operating systems. Specifically, I
will be looking to create a device driver for a simple hardware item -
specifically a generic parallel port driver - operating on the Windows NT
and FreeBSD operating systems. As part of the project, I will be submitting
a paper outlining the differences between the structures of device drivers
for those two operating systems. In this paper, I hope to list various
abstractions in the structures of device drivers for the two OSs
with the
intention of coming up with a 'pseudo' device driver summarizing the
structure as close as possible for each OS.'
|
| |
|
Literature Survey
|
| |
|
Final Report
|
|
|
C and Java performance comparisons on Palm OS PDA device.
|
|
| |
|
Zhi K. Xin
|
| |
|
I will implement various algorithms in both C and Java, and they will be
executed on my Palm IIIxe running Palm OS 3.5 with 8MB. Basically I will
like to learn about the performances of both C and Java running in the
embedded system. Java development will be done using JDK1.4 and Mobile
Information Device Profile(MIDP) APIs, Java Micro Edition. C development
will be done using GNU based PRC-TOOL and Cygwin library. Initial testing
will be performed on Palm OS emulator 5.0. Eventually all executables will
be transferred to the actual Palm device using the HotSync software and
the final tests will be ran on the device itself. Performance measuring
will be based on execution time and possibly memory usage if time permits.
I still have to think about what algorithms to implement, but they should
be computational intensive, sorting for example. I will have to learn
about the Palm OS C library and Java MIDP APIs. Overall, I think this
project will show the performances of both C and Java running on the PDA
device and I will learn in great depth about the Palm OS development.
|
| |
|
Literature Survey
|
| |
|
Literature Survey Presentation
|
| |
|
Literature Survey Presentation
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
| |
|
Final Report Script
|
|
|
Implementing a Domain Specific Language for Network Drivers
|
|
| |
|
Russell Yanofsky
|
| |
|
I want to pick up where one of last years projects
"A Specific Domain
Language for Network Interface Cards" (by Apostolos Manolitzas) left off
and to actually implement such a language for writing NIC driver code.
But rather than writing a code generator that reads high level hardware
descriptions and outputs lower level C code
I will write a C++ library
that uses C++'s extensible semantics (operating overloading and
user-defined types) and code generation capabilities (templates and
macros) to build high level features in standard C++.'
|
| |
|
Literature Survey
|
| |
|
Final Report
|
|
|
Hardware Synthesis from Esterel
|
|
| |
|
Jia Zeng
|
| |
|
I am going to develop an algorithm on heuristic logic minimization
for esterel compiler. I will concentrate on two-level combinational
logic optimization. A small translator for esterel will be
constructed, using my optimize algorithm. I plan to approach from
two sides:control dependence and state encoding. I will try it on
some small esterel programs and compare the result with the exist
esterel compiler.
|
| |
|
Literature Survey
|
| |
|
Literature Survey Presentation
|
| |
|
Final Report
|
| |
|
Final Report Presentation
|
|
|
StrongARM Simulator
|
|
| |
|
Shuqiang Zhang
|
| |
|
Ill be building a simulator for StrongARM processor in C running
on an Intel Pentium III processor. My main goal of the project is
be able to run sample instruction sets for the StrongARM processor
and get correct results back
the initial plan of accomplishing
this is to create C functions that will mimic the behaviors of each
StrongARM instructions
and find a good parser to parse the sample
instruction sets so they can be mapped correctly to each
corresponding C functions. If time permits
|
| |
|
Literature Survey
|
| |
|
Final Report
|
