Topic
System Generation
About: System Generation is a research topic. Over the lifetime, 37 publications have been published within this topic receiving 245 citations.
Papers
Book•
1 Jan 1980
TL;DR: An integrated software development and maintenance environment that supports communication and cooperation among programmers is discussed that permits the total separation of logical and physical interfaces.
Abstract: Constructing large software systems is not merely a matter of programming but also a matter of human interaction. Problems arise because a number of people work on a joint project and need to cooperate. This dissertation discusses an integrated software development and maintenance environment that supports communication and cooperation among programmers. The environment has three aspects: (1) Representation. A notation to describe the overall structure of a programmed system is the basis of the environment. This notation is a module interconnection language called INTERCOL. It can represent multiple versions and configurations, written in multiple programming languages. The notation contains enough information for automating interface control and version control. (2) Interface Control. The environment establishes consistent interfaces among separately developed software components and maintains this consistency when modifications are made. It automates the management of interface changes by determining the affected components, alerting the responsible programmers, and preventing the use of inconsistent components. (3) Version Control. The environment coordinates the creation and change of source program versions and implements system generation in a multi-version, multi-configuration environment. In particular, the environment ensures that a system remains in a well-defined state by permitting only operations that are meaningful at a given state. It determines which versions of which components should be combined to form a particular version of a particular configuration. It handles compilation, recompilation and integration automatically. It manages the storage of derived objects like object modules and and partially linked subsystems and tries to optimize the space/time tradeoff of storing or regenerating them.
INTERCOL is presented in the form of a concise reference manual. It is accompanied by a design rationale, motivating the major design decisions. The suitability of INTERCOL is demonstrated by a number of examples.
We discuss design and implementation of interface control and version control in detail. To facilitate system generation, a flexible compilation/integration mechanism is developed that permits the total separation of logical and physical interfaces.
We describe a prototype implementation, running on a PDP11/40 under the UNIX operating system. The prototype is based on a simplified version of INTERCOL and provides full interface control. Two closely related programming languages, C and TC (type-checked C) may be used for programming. Version control is only partially implemented.
57 citations
1 Sep 1994
TL;DR: This paper provides an overview of TimeBench, a prototype CAD tool for designing real-time systems, as well as some experiences gained through building and using it.
Abstract: This paper provides an overview of TimeBench, a prototype CAD tool for designing real-time systems, as well as some experiences gained through building and using it. TimeBench aims to support a true engineering design process for real-time systems in a largely graphical working environment. The environment includes support for design synthesis, analysis, and system generation, with equal emphasis on the design of operational structure and the design of temporal behavior. Its main features include: (1) a hybrid graphical---textual design description notation (MachineCharts, Abstract Controller Machines, and MachineChart Language), (2) design experimentation through an embedded interpreter and behavior visualization tools to animate designs, (3) further design evaluation through a performance modelling tool based on fast approximate analystic methods, and (4) a code generation system than can be tailored to produce code for a desired environment.
11 citations
13 Nov 1998
TL;DR: A new language is defined to achieve portability between application software from different electronic control units (ECU) by specifying means to declare and define all relevant OS-objects in a centralized OIL-file.
Abstract: The main purpose of the OSEK operating system (OS) specification is to achieve portability between application software from different electronic control units (ECU). Because the specification ends with defining an API on C-language level together with the declaration of the relevant datatypes, applications still are not portable between OS-implementations of different vendors. Since it's not very meaningful to prescribe the detailed implementation of OSEK datatypes to the operating system vendors a new language is defined to achieve portability. The OSEK implementation language (OIL) specifies means to declare and define all relevant OS-objects. Currently it is intended to specify all OS-objects for an application in a centralized OIL-file. Defining a new language for system description also implies the introduction of new tools. OIL-files have to be parsed to collect the specified informations and translated into C data structures and probably some code. This task will be typically handled by a system generation tool (SysGen) which will be delivered by the operating system vendor.
10 citations
Journal Article•
TL;DR: It is argued that adequate content modeling has to be open to changes, and content management systems have to react to changes dynamically, thus making content management a case for dynamic system generation.
Abstract: Database modeling is based on the assumption of a high regularity of its application areas, an assumption which applies to both the structure of data and the behavior of users. Content modeling, however, is less strict since it may treat one application entity substantially differently from another depending on the instance at hand, and content users may individually add descriptive or interpretive aspects depending on their knowledge and interests. Therefore, we argue that adequate content modeling has to be open to changes, and content management systems have to react to changes dynamically, thus making content management a case for dynamic system generation. In our approach, openness and dynamics are provided through a compiler framework which is based on a conceptual model of the application domain. Using a conceptual modeling language users can openly express their views on the domain's entities. Our compiler framework dynamically generates the components of an according software system. Central to the compiler framework is the notion of generators, each generating a particular module for the intended application system. Based on the resulting modular architecture the generated systems allow personalized model definition and seamless model evolution. In this paper we give details of the system modules and describe how the generators which create them are coordinated in the compiler framework.
10 citations
TL;DR: This article presents a co-design methodology based on RecoMARTE, an extension to the well-known UML MARTE profile, which is used for the specification and automatic generation of Dynamic and Partially Reconfigurable Systems-on-Chip (DRSoC).
Abstract: This article presents a co-design methodology based on RecoMARTE, an extension to the well-known UML MARTE profile, which is used for the specification and automatic generation of Dynamic and Partially Reconfigurable Systems-on-Chip (DRSoC). This endeavor is part of a larger framework in which Model-Driven Engineering (MDE) techniques are extensively used for modeling and via model transformations, generating executable models, which are exploited by implementation tools to create reconfigurable systems. More specifically, the methodological aspects presented in this article are concerned with expediting the conception and implementation of the hardware platform and the integration of correct by construction reconfiguration controller. This article builds upon previous research by integrating previously separated endeavors to obtain a complete PR system generation chain, which aims at shielding the designer of many of the burdensome technological and tool-specific requirements. The methodology permits for the verification of the platform description at different stages in the development process (i.e., HDL for simulation, static FPGA implementation, controller simulation and verification). Furthermore, automation capabilities embedded in the flow enable the generation of the platform description and the integration of the reconfiguration controller executive seamlessly. In order to demonstrate the benefits of the proposed approach, we present a case study in which we target the creation of an image-processing application to be deployed onto an FPGA board. We present the required modeling strategies and we discuss how the generation chains are integrated with the back-end Xilinx tools (the most mature version of PR technology) to produce the necessary executable artifacts: VHDL for the platform description and a C description of the reconfiguration controller to be executed by an embedded processor.
9 citations
Related Topics (5)
Performance Metrics
| Year | Papers |
|---|---|
| 2018 | 2 |
| 2017 | 1 |
| 2016 | 2 |
| 2015 | 1 |
| 2014 | 4 |
| 2013 | 1 |