IEEE 68 Computer (original) (raw)

AWB: The Asim Architect's Workbench

Performance models are typically characterized on three metrics: model speed, model development time and model fidelity. While in many cases these metrics can simply be traded one for the other, adding modularity and reuse to a modeling infrastructure can enhance both model development time and model fidelity without significant deleterious impact on model speed. This paper describes the Asim Architect's Workbench, AWB, which aims to be a practical plug-n-play mechanism that can improve development time by reusing portions of existing models, and can easily allow fidelity trade-offs. Furthermore, AWB can enhance that aspect of fidelity related to correctness through the reuse of more highly debugged modules and through the ability to plug in and test a module in multiple environments. AWB and the Asim infrastructure [ASIM] have been in use for almost 10 years at DEC, Compaq and Intel. A large number of models have been developed and over 20 distinct repositories are in use. This infrastructure has repeatedly demonstrated opportunities for module reuse at the fine grain, e.g., branch-predictor algorithms as well as at the coarse grain where entire CPU pipelines or memory hierarchies are reused. This reuse has often resulted in greatly enhanced model development time for high-fidelity models.

A Basic Performance Model Interchange Format

This paper describes a mechanism to enable users of performance modeling tools to transfer models among a set of tools. This paper describes the evolution and definition of a basic PMIF. It describes how tool developers can implement the PMIF and how the export and import would work for users. A simple example illustrates the format. The paper describes how to extend the PMIF to add new features to the basic format. It ends with the current status of the PMIF, what we have learned, some suggestions for sets of extensions, and current work in progress.-3-© 1997 by the authors changes to them. The performance model solution process should be transparent to the user of the SPE tool. These requirements led to the initial version of the PMIF [SMI94b]. They also led to an SPE meta-model that defines the information requirements for SPE [WILL95]. The SPE meta-model can be used by developers of CASE tools who wish to collect data and provide for tool inter-operability with SPE tools to provide performance data for design analysis. It can also be used to exchange models among software performance modeling tools. Note that the PMIF is intended for system performance models that represent computer platforms and network interconnections with a network of queues and servers. The SPE meta-model, however, represents the software processing steps and other information for workloads that execute on the system performance model. This difference is explained in [SMIT90a;SMI96].

Experiments with a Runtime Component Model

2010

Abstract. This paper provides a brief description of a general-purpose component model called OpenCom and also outlines the results obtained from the experiments with such a component model. The evaluation adopts a dual approach: first, we measure the inherent performance properties and overhead incurred by OpenCom. Then, we present three case studies which evaluate OpenCom's adaptive architecture in constructing system software for a wide range of domains.

Performance analysis of real-time component architectures: An enhanced model interchange approach

Performance Evaluation, 2010

Model interchange approaches support the analysis of software architecture and design by enabling a variety of tools to automatically exchange performance models using a common schema. This paper builds on one of those interchange formats, the Software Performance Model Interchange Format (S-PMIF), and extends it to support the performance analysis of real-time systems. Specifically, it addresses real-time system designs expressed in the Construction and Composition Language (CCL) and their transformation into the S-PMIF for additional performance analyses. This paper defines extensions and changes to the S-PMIF meta-model and schema required for real-time systems. It describes transformations for both simple, best-case models and more detailed models of concurrency and synchronization. A case study demonstrates the techniques and compares performance results from several analyses.

Parameter dependencies for reusable performance specifications of software components

2008

To avoid design-related per­for­mance problems, model-driven performance prediction methods analyse the response times, throughputs, and re­source utilizations of software architectures before and during implementation. This thesis proposes new modeling languages and according model transformations, which allow a reusable description of usage profile dependencies to the performance of software components. Predictions based on this new methods can support performance-related design decisions.

The Liberty Structural Specification Language: A high-level modeling language for component reuse

ACM SIGPLAN Notices, 2004

Rapid exploration of the design space with simulation models is essential for quality hardware systems research and development. Despite striking commonalities across hardware systems, designers routinely fail to achieve high levels of reuse across models constructed in existing general-purpose and domain-specific languages. This lack of reuse adversely impacts hardware system design by slowing the rate at which ideas are evaluated. This paper presents an examination of existing languages to reveal their fundamental limitations regarding reuse in hardware modeling. With this understanding, a solution is described in the context of the design and implementation of the Liberty Structural Specification Language (LSS), the input language for a publicly available high-level digital-hardware modeling tool called the Liberty Simulation Environment. LSS is the first language to enable low-overhead reuse by simultaneously supporting static inference based on hardware structure and flexibility via parameterizable structure. Through LSS, this paper also introduces a new type inference algorithm and a new programming language technique, called use-based specialization, which, in a manner analogous to type inference, customizes reusable components by statically inferring structural properties that otherwise would have had to have been specified manually.

A Performance Model Interchange Format

1995

A Performance Model Interchange Format (PMIF) provides a mechanism whereby system model information may be transferred among performance modeling tools. The PMIF allows diverse tools to exchange information and requires only that the importing and exporting tools support the PMIF. This paper presents the definition of a PMIF by describing a meta-model of the information requirements and the transfer format derived from it. It describes how tool developers can implement the PMIF, how the model interchange via export and import works in practice, and how the PMIF can be extended. A simple case study illustrates the format. The paper concludes with the current status of the PMIF, lessons learned, some suggestions for extensions, and current work in progress. 2 1. Introduction A performance model interchange format (PMIF) is a common representation for system performance model data that can be used to move models among modeling tools. A user of several tools that support the format can ...

System-on-chip component models

2006

This report defines and describes a format for models of system components required for system-on-chip (SoC) design. In an SoC design process, starting from an initial system specification, an implementation of the system is created through a series of interactive and automated steps by gradually synthesizing and assembling a system design using components taken out of a set of databases. Generally, databases are needed for processing elements (PEs), communication elements (CEs), bus and other communication protocols, and RTL units. In this report we aim to provide an exhaustive list of requirements for components in an automated SoC design flow using the example of a concrete database format. Following a description of the basic database format in general, this report defines the format of each of the three databases in detail. Using information in this report, specific database formats for diverse SoC design flows can be developed. Specifically, the database format in this report is used successfully in our SoC Design Environment, SCE.