Difference between revisions of "TACL Seminar Fall '03"

From CSWiki
Jump to: navigation, search
m (Fall '03 Schedule)
m (Dominic Duggan)
Line 37: Line 37:
 
This is joint work with Tom Chothia (Stevens) and Jan Vitek (Purdue
 
This is joint work with Tom Chothia (Stevens) and Jan Vitek (Purdue
 
University).
 
University).
 +
 +
===Spyros Triantafyllis===
 +
'''LIL: A portable low-level language for expressing runtime support code'''
 +
 +
The ORP managed runtime environment consists of a core virtual machine
 +
(VM), several just-in-time compilers (JITs), and a garbage collector
 +
(GC). In order to avoid exposing the VM, the JITs, and the GC to each
 +
other's implementation specifics, ORP employs a call-based
 +
runtime-support interface. Whenever the user's code requires runtime
 +
support, an ORP JIT generates calls to VM generated code stubs, which
 +
may in turn call the GC. LIL is a low-level, architecture-independent
 +
language for expressing such code stubs.  The first part of the talk
 +
describes LIL and its implementation, with emphasis on the LIL code
 +
generator for IPF. It demonstrates that LIL makes the development of
 +
runtime support stubs much easier, less error-prone, and more portable
 +
than the direct generation of such code stubs in machine
 +
language. Moreover, these gains in flexibility and maintainability
 +
come at negligible performance loss.  The second part of the talk
 +
describes how LIL can be used in order to implant VM-dependent or
 +
GC-dependent code directly into JITed code. This implanting avoids the
 +
performance losses associated with a call-based interface yet retains
 +
the modularity of ORP's components.
  
  

Revision as of 04:00, 27 August 2006

TACL Seminar

Fall '03 Schedule

Date Speaker Title Links
Sep 12 Dominic Duggan - Stevens Inst Type-Based Distributed Access Control Abstract
Sep 26 Spyros Triantafyllis LIL: A portable low-level language for expressing runtime support code Abstract

Abstracts

Dominic Duggan

Type-Based Distributed Access Control

The term 'distributed access control' is used here to refer to a weak form of information flow control, one that ensures that access control restrictions on data are propagated to all the places where it is accessed in a distributed system. The motivation for DAC is accountability: building an audit trail based on accesses to data. The key to making this practical is performing the access checks statically, at compile-time.

Various forms of type-based access control and information flow control require that network security be maintained by the runtime rather than the application. This is because the guarantees of the information flow might otherwise be violated by unsafe communication. This talk presents the 'Key-based Decentralized Label Model (KDLM)', an approach to extending a type system for distributed access control to a typed API for cryptographic operations, that ensures that the access control restrictions are preserved by the application's use of cryptography to secure communications. The notion of 'declassification certificates' is introduced to support the declassification of encrypted data.

This is joint work with Tom Chothia (Stevens) and Jan Vitek (Purdue University).

Spyros Triantafyllis

LIL: A portable low-level language for expressing runtime support code

The ORP managed runtime environment consists of a core virtual machine (VM), several just-in-time compilers (JITs), and a garbage collector (GC). In order to avoid exposing the VM, the JITs, and the GC to each other's implementation specifics, ORP employs a call-based runtime-support interface. Whenever the user's code requires runtime support, an ORP JIT generates calls to VM generated code stubs, which may in turn call the GC. LIL is a low-level, architecture-independent language for expressing such code stubs. The first part of the talk describes LIL and its implementation, with emphasis on the LIL code generator for IPF. It demonstrates that LIL makes the development of runtime support stubs much easier, less error-prone, and more portable than the direct generation of such code stubs in machine language. Moreover, these gains in flexibility and maintainability come at negligible performance loss. The second part of the talk describes how LIL can be used in order to implant VM-dependent or GC-dependent code directly into JITed code. This implanting avoids the performance losses associated with a call-based interface yet retains the modularity of ORP's components.



TACL Seminar