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

• chess09-distribution.pdf · application/pdf · 788 kbytes

• 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.