1 / 22

Enhancing Component-Based Design with System-Level Types and Interface Automata

This presentation explores the integration of system-level types into component-based design to enhance the modeling of complex, concurrent systems. It introduces the concept of interface automata to capture dynamic interactions among components, crucial for ensuring safety through type checking and promoting reuse via polymorphism. Key trade-offs between static and dynamic checks are discussed, emphasizing how type systems can reflect component behavior and interaction semantics. The session highlights the importance of compatibility, subtyping, and the implications for future design methodologies in system-level frameworks.

gwylan
Télécharger la présentation

Enhancing Component-Based Design with System-Level Types and Interface Automata

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. System-Level Types forComponent-Based Design Edward A. Lee Yuhong Xiong Presented at EMSOFT, Lake Tahoe, October 2001.

  2. Outline • Component-based design • System-level types • Interface Automata • Interaction Types and Component Behavior • Type Checking • Type Order and Polymorphism • Design Tradeoffs • Conclusion

  3. Component-Based Design • Good for designing complex, concurrent, heterogeneous systems • Two levels of interface: • data types and • dynamic interaction • Key aspects of dynamic interaction: communication & execution

  4. Type Systems • Type systems are successful • Safety through type checking • Polymorphism supports reuse (flexible components) • Interface documentation, clarification • Run-time reflection of component interfaces • Data types only specify static aspects of interface • Proposal: • Capture the dynamic interaction of components in types • Obtain benefits analogous to data typing. • Call the result system-level types.

  5. Interaction Semantics • Flow of control issues (“execution model” - Sifakis) • in Ptolemy II, these are defined by a Director class • Communication between components (“interaction model”) • in Ptolemy II, this is defined by a Receiver class Actor interface for execution: fire Receiver interface for communication: put, get, hasToken

  6. Models of Computation • Define the interaction semantics • Implemented in Ptolemy II by a domain • Receiver + Director • Examples: • Communicating Sequential Processes (CSP): rendezvous-style communication • Process Networks (PN):asynchronous communication • Synchronous Data Flow (SDF):stream-based communication, statically scheduled • Discrete Event (DE):event-based communication • Synchronous/Reactive (SR):synchronous, fixed point semantics

  7. Receiver Object Model

  8. Formal Interaction Semantics:Use Interface Automata • Automata-based formalism • Proposed by de Alfaro and Henzinger • Optimistic • Concise composition • Compatibility checking • Done by automata composition • Captures the notion “components can work together” • Alternating simulation (from Q to P) • All input steps of P can be simulated by Q, and • All output steps of Q can be simulated by P. • Provides the ordering we need for subtyping & polymorphism • A key theorem about compatibility and alternating simulation

  9. Example: SDF Consumer Actor Outputs: Inputs:

  10. Type Definition - SDFDomain

  11. Type Definition - DEDomain

  12. Component BehaviorSDF Consumer Actor

  13. Type CheckingSDF Consumer Actor in SDFDomain SDFDomain SDF Consumer Actor Compose

  14. Type CheckingSDF Consumer Actor in SDFDomain

  15. Type CheckingSDFActor in DEDomain • Empty automata indicating incompatibility Compose DEDomain SDF Consumer Actor

  16. Alternating SimulationSDF to DE DEDomain SDFDomain 

  17. System-Level Type OrderDefined by Alternating Simulation • Analogous to subtyping • If an actor is compatible with a certain type, it is also compatible with the subtypes

  18. Component BehaviorDomainPolymorphicActor

  19. DomainPolymorphicActor is Compatible with DEDomain Poly Actor Compose DEDomain

  20. So it is also Compatible with SDFDomain Poly Actor SDFDomain Compose

  21. Trade-offs in Type System Design • Amount of property checked vs. cost of checking • Static vs. run-time checking • Example of more static checking: deadlock detection in Dining Philosopher model • Bottom line: static checking of communication protocols a good starting point

  22. Conclusion and Future Work • We capture dynamic property of component interaction in a type system framework: system-level types • We describe interaction types and component behavior using interface automata. • We do type checking through automata composition. • Subtyping order is given by the alternating simulation relation, supporting polymorphism. • We can reflect component state in a run-time environment, providing system-level reflection.

More Related