TL;DR: This paper describes the implementation of the runtime environment for the SOFA 2.0 component model and focuses on the runtime support of the advanced features mentioned above.
Abstract: Component-based development has become a recognized technique for building large scale distributed applications. Although the maturity of this technique, there appears to be quite a significant gap between (a) component systems that are rich in advanced features (e.g., component nesting, software connectors, versioning, dynamic architectures), but which have typically only poor or even no runtime support, and (b) component systems with a solid runtime support, but which typically possess only a limited set of the advanced features. In our opinion, this is mainly due to the difficulties that arise when trying to give proper semantics to the features and reify them in development tools and an runtime platform. In this paper, we describe the implementation of the runtime environment for the SOFA 2.0 component model. In particular, we focus on the runtime support of the advanced features mentioned above. The described issues and the solution are not specific only to SOFA 2.0, but they are general and applicable to any other component system aiming at addressing such features.
TL;DR: It is shown that existing approaches cannot guarantee the correctness of component bindings in dynamic adaptive systems, therefore a technique for runtime testing is introduced and it is shown how it can be integrated into a component-based approach.
Abstract: Component-based software engineering has been continuously improved and successfully applied over the past years. Future systems, like ultra-large scale systems, are a vast array of decentralized, distributed, autonomic, heterogeneous, organically grown and continually evolving subsystems respectively components. Components may join or leave these systems during the life cycle of these systems, even at runtime. Despite this enormous complexity, we depend more and more on these dynamic adaptive systems. Hence we have to care about dependability although the systems are evolving at runtime. To achieve dependable dynamic adaptive systems which support hot plug and binding of components during runtime we claim to integrate specific concepts, like runtime testing, into the component infrastructure. In this paper we will show that existing approaches cannot guarantee the correctness of component bindings in dynamic adaptive systems. Therefore we introduce a technique for runtime testing and show how it can be integrated into a component-based approach.
TL;DR: This work proposes a mixed-signal verification methodology that covers the aforementioned as well as additional aspects required for a successful coverage closure and is applied to a smart power application to demonstrate its potential and outline the gained benefits.
Abstract: The complexity of integrated circuits is continuously increasing, leading to a growing demand for methodologies that offer comprehensive mixed-signal verification concepts. However, compared to the highly automated verification methodologies in the digital domain, pre-silicon verification in the analog domain usually implies a substantial amount of manual work and computational effort. In order to meet the rising challenges, various attempts were made to extend well-established approaches from the field of digital verification to also enable systematic mixed-signal verification. However, no methodology could be identified that meets our requirements for high reusability and maintainability, tool independence as well as capabilities for functional coverage collection. For this reason, we propose a mixed-signal verification methodology that covers the aforementioned as well as additional aspects required for a successful coverage closure. The presented concept is applied to a smart power application to demonstrate its potential and outline the gained benefits.
TL;DR: In this article, the authors present a system that facilitates the development and execution of a software program by restricting a variable to a runtime context in the software program and preventing incorrect execution by ensuring that a closure capturing the variable executes within the identified runtime context.
Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system provides a mechanism for restricting a variable to a runtime context in the software program. Next, the system identifies the runtime context during execution of the software program. Finally, the system uses the mechanism to prevent incorrect execution of the software program by ensuring that a closure capturing the variable executes within the identified runtime context.
TL;DR: Integrated proof flow as discussed by the authors is a technique that integrates verification and non-formal verification to prove one or more properties in a circuit design, such as bounded verification, multi-point proof, and/or vector-based simulation.
Abstract: Integrated proof flow methods and apparatuses are discussed. Integrated proof flow refers to attempting both formal verification and nonformal verification. A coverage metric can be changed by both attempting formal verification and by attempting nonformal verification. Some embodiments of the present invention provide proof flow methods that integrate verification and nonformal verification (e.g., bounded verification, multi-point proof, and/or vector-based simulation) to prove one or more properties in a circuit design.