Fall semester seminar meets in the DSL conference room on Mondays
from 2:00 to 3:30 p.m.
Spring semester seminar meets in the DSL conference room on Thursdays from Noon to 1:30 p.m.
On occasion, it may be rescheduled to
accommodate guest speakers.
|
September 21
(note: not usual time):
Iliaj Hadzic
Much research has been recently directed towards building
flexible and reconfigurable network infrastructures which provide
better functionality and allow faster evolution. Two classes of
reconfigurable networks have been investigated: adaptive protocols and
programmable (active) networks.
An adaptive protocol can modify itself in the face of changing network
conditions and dynamically optimize its structure. The motivation
for such protocols is the intuition that a
system specialized
to the current set of conditions will perform better
than the one designed for the common case. In addition,
adaptive systems can offer greater functionality than statically
architected systems.
Programmable or active networks have been proposed as a
way of accelerating the deployment and support of new services.
The rationale
is that if the network were programmable, the protocol
support for the new service could be rapidly implemented
without the need for standardization process at the
service level. Once the service is adopted, its implementation can be
easily
distributed over the network as long as interoperability exists at the
programming level. Non-adoption of unattractive or poorly implemented
services
also becomes less costly than in traditional approach.
Several software-only prototypes of active networks have
been built. Performance
limitations and a tacit assumption that protocol flexibility
requires software has generated a considerable
amount of skepticism about applicability when the network performance
is climbing rapidly.
We make two major contributions in this thesis. First, we demonstrate
how results in the field of Reconfigurable Computing
can be applied
in constructing a reconfigurable network protocol, improving the performance
by delegating ``bit-intensive'' functions to hardware. Second, we
extract the safety and security issues addressed in this concept and project
them to general system utilizing programmable logic and thus open the new
subfield of Reconfigurable Computing, namely security of reconfigurable
systems.
The methodology we use is a proof-of-concept through experimentation.
We have identified the existence of bit-intensive functions
in network protocols
and built the run-time reconfigurable system to accelerate these
functions.
Our experimental platform, the Programmable Protocol Processing
Pipeline (P4) is optimized for network processing and composes
a set of field-programmable logic arrays (FPGA) into a processing
engine achieving
the processing performance of a special purpose hardware with the
software-like
flexibility.
Using this platform and one of the proposed frameworks for building
adaptive
and programmable protocols, we demonstrate that the reconfigurable hardware
can be used for building reconfigurable networks. This demonstrates that
on-the-fly hardware programmability can be applied in many
settings such as line cards, switches, routers, etc.
|
|
September 27:
Emre Ucok
Performance issues in Reporting Systems Design
In corporations who have a very large flow of information, reporting issues
are often addressed by systems implemented out of a collection of independent
off-the-shelf components. Does it always pay to convert to a single
integrated tool that is aimed more narrowly at your problem, but is
potentially less customizable? I report on my experience evaluating just
such a change at the Regulatory Technology Department, Goldman Sachs and
Company.
The department processes the incoming data streams (with different rates and
periods) from many upstream systems and consolidates it to maintain detailed
information on all of the firm's current and past positions. A very critical
portion of Goldman Sachs' business depends on the timely flow and processing
of this information. These are monitored by analyzing the batch, feed,
processing time and other data stored in the main database (LEW-Legal Entity
Workstation) in the Regulatory department.
This analysis is currently done by a collection of independent tools such as
Excel and Sybase. The senior staff believed that converting this monitoring
to a single, object-oriented, integrated query, analysis, and reporting tool
(Business Objects) would have several advantages:
- a better front end
- more sophisticated reporting and analysis features
- would allow controllers to rapidly define their own queries
Despite these claimed advantages, and despite my discovery that the existing
system was allowing the main data base to have inconsistencies, I concluded
that the potential advantages of switching to Business Objects were not
sufficient to justify a change. As a result of my work, conversion of the
system to Business Objects was shelved.
One interesting minor finding was that users have unrealistic expectations of
the ability of universe-oriented systems to enable controllers to dynamically
define custom queries. I found that complex and composite SQL queries are
often that way due to the fundamental complexity of the analysis being done,
and therefore the GUI or drag and drop approaches (as in Business Objects) may
be a liability when designing such a multiple page query.
|
|
October 4 - Practice Thesis Proposal
(regular dsl seminar time)
October 11 - Thesis Proposal:
Mike Hicks
1:00 pm
Dynamic Software Updating
A dynamically updateable system may be changed at runtime to add or
alter functionality for the purpose of bug-fixes, improved efficiency, or
customizability. We propose to improve on the practice of writing
dynamically updateable systems in three ways:
- Generality
We present a simple strategy for compiling and linking dynamically
updateable programs that is not tied to a particular source language.
This strategy allows any portion of the program to be updated at any time
with minimal user intervention.
- Safety
All updates, whether additions or alterations, are guaranteed to be
type-safe, ensuring program integrity. Exact knowledge of the running
program's code is not required. In combination, these properties allow
updates to originate from multiple sources.
- Security
Loading new or replacement code is an explicit, controllable
operation. This allows programmers to formulate strategies, such as
module-thinning, for securing updates.
Intuitively, a dynamic update to a program is valid if the program
behaves as expected following the update. We will develop requirements for
achieving update validity and provide guidelines for ensuring that updates
meet these requirements.
Active networks are an important client of the proposed updating
system; active networks are programmable for the purposes of improved
adaptability and customizability, allowing updates to potentially any part
of the system, from multiple sources. To validate our approach, we will
implement both the proposed updating system and an active network
implementation, PLANet, using our system. With PLANet,
we will demonstrate many varied changes and show that these changes ensure
safety, security, and validity.
|
October 25
DSL orientation
|
November 1
No seminar today
|
November 8
Jon Moore
SNAP: Safe and Effective Active Packets
We present a new scheme for *active*, or programmable, packets based
upon a new packet language, SNAP (Safe Networking with Active
Packets). SNAP's semantics permit us to prove that all SNAP programs are
safe with respect to network resource usage and evaluation
isolation. Furthermore, we describe an implementation of a SNAP interpreter,
*snapd*, which achieves high performance for standard networking
tasks. This work represents the first active packet system that is
demonstrated to be *both* safe and efficient.
|
November 15
Yuval Shavitt: Lucent Bell Laboratories
Active networks: practice and theory
In this talk I will describe ABLE, the active bell-labs engine,
some network management applications we devised for ABLE,
and a general algorithmic model that we developed to analyze them.
ABLE is an adjunct active processor that can be added to any
commercially of the shelf (COTS) router, and transform it to an active
router. Using filters in the router, control packets (as well as
other designated packet) are deflected by the COTS router to ABLE
for processing. ABLE supports long term applications that are
typical for the network management domain, as well as capsules.
Our model is suitable for analysis of algorithmic
solutions for most active network prototypes. It captures the
different delay inflicted on a packet whether it is processed by
a short-delay module (e.g., the COTS router or the NodeOS) or by a slow
software centric process (ABLE or some EE in the DARPA model).
- Joint work with Danny Raz
|
December 6
Micheal Greenwald
"Is TCP really TCP-Friendly? Problems with the Internet's paradigm for congestion control"
Download slides ('97 ppt)
View slides (html)
|
December 13
Angelos Keromytis
Strongman
The increasing complexity and scale of networks make security management
difficult. STRONGMAN (Scalable TRust Of Next Generation MANagement) addresses
this issue by introducing a security policy interoperability layer based on a
trust management system, and a high level specification language. In this talk
I will give an overview of the architecture and the system, as well as some
thoughts on future directions.
|
December 20
Sotiris Ioannidis
Sub-Operating Systems: A New Approach to Application Security
In the current highly interconnected computing environments, users
regularly use insecure software. Many popular applications, such as
Netscape Navigator and Microsoft Word, are targeted by hostile applets or
malicious documents, and might therefore compromise the integrity of the
system. Current operating systems are unable to protect their users from this kind of attacks, since the hostile software is running with the user's
privileges and permissions.
We introduce the notion of the SubOS, a process-specific protection
mechanism. Under SubOS, any application that might deal with incoming,
possibly malicious objects, behaves like an operating system.
It views those objects the same way an operating system views users-
it assigns sub-user id's-and restricts their accesses to the
system resources.
|
Despite these claimed advantages, and despite my discovery that the existing
system was allowing the main data base to have inconsistencies, I concluded
that the potential advantages of switching to Business Objects were not
sufficient to justify a change. As a result of my work, conversion of the
system to Business Objects was shelved.
One interesting minor finding was that users have unrealistic expectations of
the ability of universe-oriented systems to enable controllers to dynamically
define custom queries. I found that complex and composite SQL queries are
often that way due to the fundamental complexity of the analysis being done,
and therefore the GUI or drag and drop approaches (as in Business Objects) may
be a liability when designing such a multiple page query.
|
October 4 - Practice Thesis Proposal
(regular dsl seminar time)
October 11 - Thesis Proposal:
Mike Hicks
1:00 pm
Dynamic Software Updating
A dynamically updateable system may be changed at runtime to add or
alter functionality for the purpose of bug-fixes, improved efficiency, or
customizability. We propose to improve on the practice of writing
dynamically updateable systems in three ways:
- Generality
We present a simple strategy for compiling and linking dynamically
updateable programs that is not tied to a particular source language.
This strategy allows any portion of the program to be updated at any time
with minimal user intervention.
- Safety
All updates, whether additions or alterations, are guaranteed to be
type-safe, ensuring program integrity. Exact knowledge of the running
program's code is not required. In combination, these properties allow
updates to originate from multiple sources.
- Security
Loading new or replacement code is an explicit, controllable
operation. This allows programmers to formulate strategies, such as
module-thinning, for securing updates.
Intuitively, a dynamic update to a program is valid if the program
behaves as expected following the update. We will develop requirements for
achieving update validity and provide guidelines for ensuring that updates
meet these requirements.
Active networks are an important client of the proposed updating
system; active networks are programmable for the purposes of improved
adaptability and customizability, allowing updates to potentially any part
of the system, from multiple sources. To validate our approach, we will
implement both the proposed updating system and an active network
implementation, PLANet, using our system. With PLANet,
we will demonstrate many varied changes and show that these changes ensure
safety, security, and validity.
|
October 25
DSL orientation
|
November 1
No seminar today
|
November 8
Jon Moore
SNAP: Safe and Effective Active Packets
We present a new scheme for *active*, or programmable, packets based
upon a new packet language, SNAP (Safe Networking with Active
Packets). SNAP's semantics permit us to prove that all SNAP programs are
safe with respect to network resource usage and evaluation
isolation. Furthermore, we describe an implementation of a SNAP interpreter,
*snapd*, which achieves high performance for standard networking
tasks. This work represents the first active packet system that is
demonstrated to be *both* safe and efficient.
|
November 15
Yuval Shavitt: Lucent Bell Laboratories
Active networks: practice and theory
In this talk I will describe ABLE, the active bell-labs engine,
some network management applications we devised for ABLE,
and a general algorithmic model that we developed to analyze them.
ABLE is an adjunct active processor that can be added to any
commercially of the shelf (COTS) router, and transform it to an active
router. Using filters in the router, control packets (as well as
other designated packet) are deflected by the COTS router to ABLE
for processing. ABLE supports long term applications that are
typical for the network management domain, as well as capsules.
Our model is suitable for analysis of algorithmic
solutions for most active network prototypes. It captures the
different delay inflicted on a packet whether it is processed by
a short-delay module (e.g., the COTS router or the NodeOS) or by a slow
software centric process (ABLE or some EE in the DARPA model).
- Joint work with Danny Raz
|
December 6
Micheal Greenwald
"Is TCP really TCP-Friendly? Problems with the Internet's paradigm for congestion control"
Download slides ('97 ppt)
View slides (html)
|
December 13
Angelos Keromytis
Strongman
The increasing complexity and scale of networks make security management
difficult. STRONGMAN (Scalable TRust Of Next Generation MANagement) addresses
this issue by introducing a security policy interoperability layer based on a
trust management system, and a high level specification language. In this talk
I will give an overview of the architecture and the system, as well as some
thoughts on future directions.
|
December 20
Sotiris Ioannidis
Sub-Operating Systems: A New Approach to Application Security
In the current highly interconnected computing environments, users
regularly use insecure software. Many popular applications, such as
Netscape Navigator and Microsoft Word, are targeted by hostile applets or
malicious documents, and might therefore compromise the integrity of the
system. Current operating systems are unable to protect their users from this kind of attacks, since the hostile software is running with the user's
privileges and permissions.
We introduce the notion of the SubOS, a process-specific protection
mechanism. Under SubOS, any application that might deal with incoming,
possibly malicious objects, behaves like an operating system.
It views those objects the same way an operating system views users-
it assigns sub-user id's-and restricts their accesses to the
system resources.
|
Feb. 3
Mike Hicks
"Active Network vision and reality: lessons from a capsule-based
system" by David Wetherall.
PS format
PDF format
|
Feb. 10
Jon Moore
SNAP: Safe Networking with Active Packets
We describe a new language for encoding active, or programmable,
packets. SNAP is an expression-limited bytecode language, permitting both
safety proofs about resource usage as well as efficient evaluation. SNAP is
the first active packet system to be both safe *and* efficient. We describe
an in-kernel implementation (with some preliminary benchmark results) and
talk about applications for SNAP.
|
|
Feb. 17
Improving network utilization
Danny Raz raz@research.bell-labs.com
This talk has two parts, each dealing with a different aspect
of improving network utilization and end to end performance.
The first one studies network cache placement, with a special emphasis
on transparent caches. The goal is to minimize the overall flow or
the average delay by optimally placing a given number of caches in
the network. We present a model that captures the essentials of the
cache location problem, and present a computationally efficient
dynamic-programming algorithm for the single server case.
We experimentally study and validate our model and algorithms using
real web data. We observe that a small number of caches are sufficient
to reduce the network traffic significantly. Furthermore, there is a
surprising consistency over time in the relative amount of web traffic
from the server along a path, lending a stability to this type of cache
location solutions.
The second part of the talk addresses one of the substantial
drawbacks of current network management systems. Many of these systems
perform periodic polling that imposes a significant load on the network.
We propose methods for efficient monitoring of data network. In this
work we present a new model that allows quantifying the efficiency of
polling, and develop new heuristics for efficient polling.
This talk is based on joint work with J. Jiao, P. Krishnan,
S. Naqvi, Y. Shavitt, and B. Sugla.
About the speaker:
Danny Raz received his doctoral degree from the Weizmann Institute
of Science, Israel, in 1995. From 1995 to 1997 he
was a post-doctoral fellow at the International Computer Science
Institute, (ICSI) Berkeley, CA, and a visiting lecturer at the
University of California, Berkeley. Since October 1997 he is
with the Network and Service Management Research Department at
Bell-Labs. His primary research interest is the theory and
application of management related problems in IP networks.
|
|
Mar. 2
William Arbaugh
TBD
|
March 9
No seminar
|
March 16
No seminar - Spring Break
|
March 23
Mike Hicks
Mike will talk about ELF format and dynamic linking.
Useful Links:
Linkers & Loaders by John R. Levine
Tools Interface Standards (has ELF spec)
ELF Kickers (useful little ELF programs)
|
April 6
Vanu Bose
Vanu Inc.
TITLE: Software Radio Using a General Purpose Processor
Many of the limitation of today's wireless communications systems,
such as multiple incompatible standards and the inability to
dynamically optimize to the mobile environment result from a lack of
flexibility in the physical layer. Software radio, the implementation
of wireless physical layer functionality in software, provides the
flexibility needed to overcome these limitations.
This talk presents a software radio architecture which is based on
wideband digitization, a general purpose processor and application
level software. The talk will highlight three areas: software radio
system design, software engineering requirements, and the design of
software signal processing algorithms suited for a general purpose
processor.
The system has been used to implement a wireless communication system
in which all of the signal processing from the air interface through
the application is performed in software. The only functions performed
by dedicated hardware are the down conversion and digitization of a
wide band (e.g. 15 MHz) of the RF spectrum. Several radio applications
including an AMPS cellular receiver and a network link employing
frequency hopping with FSK modulation have been implemented and
measured on this system.
The talk describes the system design issues associated with the I/O
system for handling wideband sampled data streams and the design of a
programming environment supporting real-time signal processing
applications on a general purpose system.
|
April 13
Suresh Jagannathan
NECI
MLton: A Whole-Program Optimizing Compiler for Standard ML
Suresh Jagannathan
NEC Research Institute
MLton is a novel optimizing compiler for Standard ML that
differs from other SML implementations in three
important respects:
- The intermediate languages upon which optimizations are
performed are all simply typed.
- Control-flow information used to drive interprocedural
important optimizations such as closure-conversion is based
on a global flow analysis that generalizes 0CFA. Closure
conversion is handled via dispatch code at call-sites, with
coercions inserted in the target program whenever flow
analysis indicates distinct closures with different
representations flow into the same program point.
- MLton is a whole-program compiler. All uses of functors
and structures are eliminated early in the compilation
process. To accomodate the simply-typed intermediate
languages used in the latter stages of the compiler, all
uses of polymorphism are also eliminated in early stages of
compilation. MLton compiles to C.
Experimental results over a wide-range of benchmarks
(ranging from 100 to 100K lines) indicate that the use of
whole-program compilation, global flow analysis, and
simply-typed intermediate languages leads to high-quality
and portable target code.
This is joint work with Henry Cejtin and Stephen Weeks.
|
DSL home page
CIS home page
