*banner
 

Implementing Synchronous Models on Distributed Execution Platforms
Stavros Tripakis

Citation
Stavros Tripakis. "Implementing Synchronous Models on Distributed Execution Platforms". Talk or presentation, 24, March, 2009.

Abstract
We study semantics-preserving implementation of synchronous models on asynchronous, distributed execution platforms. In particular, we show how to map synchronous block diagrams (a notation at the heart of widespread tools such as Simulink) onto a loosely time-triggered distributed architecture (LTTA). LTTA is fairly straightforward to implement as it does not require global synchronization or blocking communication. We achieve this mapping by introducing an intermediate layer, called Finite FIFO Platform (FFP). FFP is similar to a Kahn Process Network, but with finite queues. FFP can be easily implemented on top of LTTA. The key to achieving semantic preservation it to provide queue bounds that are sufficient to ensure that the FFP doesn't deadlock. This, and Kahn's determinacy result imply that the sequences of observed values in the asynchronous FFP implementation are identical to those of the original synchronous model. We also study performance of the asynchronous implementation, in terms of throughput and latency. We introduce worst-case, logical-time throughput and latency. These are "logical-time" in the sense that they depend only on the topology of the architecture and the sizes of the queues, but not on the real-time behavior of the distributed clocks. We show how logical-time throughput and latency can be computed algorithmically, and how they are related to real-time throughput and latency. We report on a simple implementation in Haskell. This is joint work with Claudio Pinello, Albert Benveniste, Alberto Sangiovanni-Vincentelli, Paul Caspi and Marco Di Natale.

Electronic downloads

Citation formats  
  • HTML
    Stavros Tripakis. <a
    href="http://chess.eecs.berkeley.edu/pubs/535.html"
    ><i>Implementing Synchronous Models on Distributed
    Execution Platforms</i></a>, Talk or
    presentation,  24, March, 2009.
  • Plain text
    Stavros Tripakis. "Implementing Synchronous Models on
    Distributed Execution Platforms". Talk or presentation,
     24, March, 2009.
  • BibTeX
    @presentation{Tripakis09_ImplementingSynchronousModelsOnDistributedExecutionPlatforms,
        author = {Stavros Tripakis},
        title = {Implementing Synchronous Models on Distributed
                  Execution Platforms},
        day = {24},
        month = {March},
        year = {2009},
        abstract = {We study semantics-preserving implementation of
                  synchronous models on asynchronous, distributed
                  execution platforms. In particular, we show how to
                  map synchronous block diagrams (a notation at the
                  heart of widespread tools such as Simulink) onto a
                  loosely time-triggered distributed architecture
                  (LTTA). LTTA is fairly straightforward to
                  implement as it does not require global
                  synchronization or blocking communication. We
                  achieve this mapping by introducing an
                  intermediate layer, called Finite FIFO Platform
                  (FFP). FFP is similar to a Kahn Process Network,
                  but with finite queues. FFP can be easily
                  implemented on top of LTTA. The key to achieving
                  semantic preservation it to provide queue bounds
                  that are sufficient to ensure that the FFP doesn't
                  deadlock. This, and Kahn's determinacy result
                  imply that the sequences of observed values in the
                  asynchronous FFP implementation are identical to
                  those of the original synchronous model. We also
                  study performance of the asynchronous
                  implementation, in terms of throughput and
                  latency. We introduce worst-case, logical-time
                  throughput and latency. These are "logical-time"
                  in the sense that they depend only on the topology
                  of the architecture and the sizes of the queues,
                  but not on the real-time behavior of the
                  distributed clocks. We show how logical-time
                  throughput and latency can be computed
                  algorithmically, and how they are related to
                  real-time throughput and latency. We report on a
                  simple implementation in Haskell. This is joint
                  work with Claudio Pinello, Albert Benveniste,
                  Alberto Sangiovanni-Vincentelli, Paul Caspi and
                  Marco Di Natale.},
        URL = {http://chess.eecs.berkeley.edu/pubs/535.html}
    }
    

Posted by Hiren Patel on 2 Mar 2009.
Groups: chess
For additional information, see the Publications FAQ or contact webmaster at chess eecs berkeley edu.

Notice: This material is presented to ensure timely dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All persons copying this information are expected to adhere to the terms and constraints invoked by each author's copyright.

You are not logged in 
©2002-2014 Chess