ECOOP / Tutorial 28

Automatic Derivation and Verification of Synchronization Aspects in Object Oriented Systems

Topic	Synchronization in Object Oriented Systems
Goal	To introduce methodologies for designing and synthesizing synchronization code in object oriented systems.
Style	presentation with examples and tool demonstration

Abstract

The goal of the tutorial is to familiarize participants with methodologies for designing and synthesizing synchronization code in object oriented systems. We will first review traditional design methodologies found in OS textbooks and motivate the need for aspect oriented programming. Although the use-case driven approach in the Rational Unified Process (RUP) in UML provides an effective way to develop code that describes a sequence of actions on classes and objects, there does not exist a standard methodology to develop code for synchronization between threads.

We will present an aspect oriented methodology based on formal specification with automatic generation of synchronization code, and discuss the integration of the methodology with RUP. Based on this methodology, we will present a pattern-based approach to synchronization. We will demonstrate (and make available on CD to participants) a tool, SynGen, that provides complete support for automatically generating synchronization code from high-level specifications and provides verification support. Integration of this methodology with other aspect oriented approaches such as AspectJ, Synchronizers and Composition Filters will be discussed.

We will discuss our experience in introducing synchronization as an aspect in:

classroom teaching -- emphasizing how synchronization issues can be taught to specialists (e.g. in traditional computer science courses) as well as non-specialists (e.g., application developers that need to deal with concurrency but are not specialists in concurrent programming).
industrial setting -- discussing how synchronization in concurrent embedded systems can be modeled as an aspect using Boeing Bold Stroke System as a case study.

An outline of the topics covered is:

Traditional approaches to synchronization
Aspect oriented approach to synchronization
Pattern-based Approach to Synchronization
SyncGen Tool Demonstration
Verification of Woven Code
Bottom-up approach to aspect oriented synchronization
Industrial Case Study of Synchronization: Boeing Bold Stroke platform
Teaching Synchronization

Presenter Profile

Gurdip Singh and Masaaki Mizuno are Professors in the Department of Computing and Information Sciences at Kansas State University. They have both conducted extensive research in the areas of distributed and concurrent systems. Their work has been funded by NSF, Darpa, ARO, Navy and various industrial partners (Trimble navigation, National Instruments, Windriver).They have also collaborated with Boeing and Rockwell Collins in developing aspect oriented approaches for designing embedded systems.

Gurdip and Masaaki have been pursuing the development of an aspect oriented approach for synchronization for the past few years. This work has been funded by DARPA and NSF. In this project, the SyncGen tool supporting algorithms for synchronization code generation for several different platforms including shared memory systems, point-to-point message passing, Controller Area Network based systems, and event-channel based systems, were developed. The technique is currently being applied to the Bold Stroke platform from Boeing for Avionics applications. The NSF grant from the Combined Research and Curriculum Development program was focussed on developing undergraduate and graduate courses in embedded systems. The aspect oriented technique has been incorporated into these courses which have been taught since Spring 2000.

Details

Presenter(s)	Gurdip Singh, Kansas State University Masaaki Mizuno, Kansas State University
Date Duration	Tuesday, 22nd July Half day
Level	Intermediate/Advanced
Targeted Audience	The tutorial should be of interest to participants that are specialist in concurrent programming (Type 1) as well as those that need to develop applications involving concurrency but do not have extensive experience in concurrent programming (Type 2). We expect that participants of Type 1 will benefit by learning how to specify synchronization as an aspect and to generate synchronization code systematically. They will be provided with sufficient details so that they can customize our methodology for their own setting (by defining their own patterns and by plugging in translation algorithms for specific platforms into the SyncGen tool). We expect that participants of Type 2 will benefit by learning a methodology based on patterns that can allow them to construct applications involving concurrency. We believe that this pattern based methodology is very useful as it masks the error-prone task of coding synchronization (the developers only needs to understand and declare the synchronization pattern required). The tutorial will also discuss our experience in teaching synchronization using aspect oriented approach in courses for both computer science students as well as students from other engineering disciplines. This will benefit participants who are teaching courses on concurrent programming.