By Sunita Chulani1, Stanley M. Sutton Jr.1, Gary Bachelor2, and P. Santhanam11 IBM T. J. Watson Research Center, 19 Skyline Drive, Hawthorne, NY 10532 USA2 IBM Global Business Services, PO BOX 31, Birmingham Road, Warwick CV34 5JL UKAbstract
Systems-on-a-Chip (SoC) are becoming increasingly complex, leading to corresponding increases in the complexity and cost of SoC design and development. We propose to address this problem by introducing comprehensive change management. Change management, which is widely used in the software industry, involves controlling when and where changes can be introduced into components so that changes can be propagated quickly, completely, and correctly.
In this paper we address two main topics: One is typical scenarios in electronic design where change management can be supported and leveraged. The other is the specification of a comprehensive schema to illustrate the varieties of data and relationships that are important for change management in SoC design.1. INTRODUCTION
SoC designs are becoming increasingly complex. Pressures on design teams and project managers are rising because of shorter times to market, more complex technology, more complex organizations, and geographically dispersed multi-partner teams with varied “business models” and higher “cost of failure.”
Current methodology and tools for designing SoC need to evolve with market demands in key areas: First, multiple streams of inconsistent hardware (HW) and software (SW) processes are often integrated only in the late stages of a project, leading to unrecognized divergence of requirements, platforms, and IP, resulting in unacceptable risk in cost, schedule, and quality. Second, even within a stream of HW or SW, there is inadequate data integration, configuration management, and change control across life cycle artifacts. Techniques used for these are often ad hoc or manual, and the cost of failure is high. This makes it difficult for a distributed group team to be productive and inhibits the early, controlled reuse of design products and IP. Finally, the costs of deploying and managing separate dedicated systems and infrastructures are becoming prohibitive.
We propose to address these shortcomings through comprehensive change management, which is the integrated application of configuration management, version control, and change control across software and hardware design. Change management is widely practiced in the software development industry. There are commercial change-management systems available for use in electronic design, such as MatrixOne DesignSync , ClioSoft SOS , IC Manage Design Management , and Rational ClearCase/ClearQuest , as well as numerous proprietary, “home-grown” systems. But to date change management remains an under-utilized technology in electronic design.
In SoC design, change management can help with many problems. For instance, when IP is modified, change management can help in identifying blocks in which the IP is used, in evaluating other affected design elements, and in determining which tests must be rerun and which rules must be re-verified. Or, when a new release is proposed, change management can help in assessing whether the elements of the release are mutually consistent and in specifying IP or other resources on which the new release depends.
More generally, change management gives the ability to analyze the potential impact of changes by tracing to affected entities and the ability to propagate changes completely, correctly, and efficiently. For design managers, this supports decision-making as to whether, when, and how to make or accept changes. For design engineers, it helps in assessing when a set of design entities is complete and consistent and in deciding when it is safe to make (or adopt) a new release.
In this paper we focus on two elements of this approach for SoC design. One is the specification of representative use cases in which change management plays a critical role. These show places in the SoC development process where information important for managing change can be gathered. They also show places where appropriate information can be used to manage the impact of change. The second element is the specification of a generic schema for modeling design entities and their interrelationships. This supports traceability among design elements, allows designers to analyze the impact of changes, and facilitates the efficient and comprehensive propagation of changes to affected elements.
The following section provides some background on a survey of subject-matter experts that we performed to refine the problem definition.
We surveyed some 30 IBM subject-matter experts (SMEs) in electronic design, change management, and design data modeling. They identified 26 problem areas for change management in electronic design. We categorized these as follows:
- visibility into project status
- day-to-day control of project activities
- organizational or structural changes
- design method consistency
- design data consistency
Major themes that crosscut these included:
- visibility and status of data
- comprehensive change management
- method definition, tracking, and enforcement
- design physical quality
- common approach to problem identification and handling
We held a workshop with the SMEs to prioritize these problems, and two emerged as the most significant: First, the need for basic management of the configuration of all the design data and resources of concern within a project or work package (libraries, designs, code, tools, test suites, etc.); second, the need for designer visibility into the status of data and configurations in a work package.
To realize these goals, two basic kinds of information are necessary: 1) An understanding of how change management may occur in SoC design processes; 2) An understanding of the kinds of information and relationships needed to manage change in SoC design. We addressed the former by specifying change-management use cases; we addressed the latter by specifying a change-management schema.
3. USE CASES
This section describes typical use cases in the SoC design process. Change is a pervasive concern in these use cases—they cause changes, respond to changes, or depend on data and other resources that are subject to change. Thus, change management is integral to the effective execution of each of these use cases. We identified nine representative use cases in the SoC design process, which are shown in Figure 1.
Figure 1. Use cases in SoC design
In general there are four ways of initiating a project: New Project, Derive, Merge and Retarget. New Project is the case in which a new project is created from the beginning. The Derive case is initiated when a new business opportunity arises to base a new project on an existing design. The Merge case is initiated when an actor wants to merge configuration items during implementation of a new change management scheme or while working with teams/organizations outside of the current scheme. The Retarget case is initiated when a project is restructured due to resource or other constraints. In all of these use cases it is important to institute proper change controls from the outset. New Project starts with a clean slate; the other scenarios require changes from (or to) existing projects.
Once the project is initiated, the next phase is to update the design. There are two use cases in the Update Design composite state. New Design Elements addresses the original creation of new design elements. These become new entries in the change-management system. The Implement Change use case entails the modification of an existing design element (such as fixing a bug). It is triggered in response to a change request and is supported and governed by change-management data and protocols.
The next phase is the Resolve Project and consists of 3 use cases. Backout is the use case by which changes that were made in the previous phase can be reversed. Release is the use case by which a project is released for cross functional use. The Archive use case protects design asset by secure copy of design and environment.
4. CHANGE-MANAGEMENT SCHEMA
The main goal of the change-management schema is to enable the capture of all information that might contribute to change management
The schema, which is defined in the Unified Modeling Language (UML) , consists of several high-level packages (Figure 2).
Click to enlarge
Figure 2. Packages in the change-management schema
Package Data represents types for design data and metadata. Package Objects and Data defines types for objects and data. Objects are containers for information, data represent the information. The main types of object include artifacts (such as files), features, and attributes. The types of objects and data defined are important for change management because they represent the principle work products of electronic design: IP, VHDL and RTL specifications, floor plans, formal verification rules, timing rules, and so on. It is changes to these things for which management is most needed.
The package Types defines types to represent the types of objects and data. This enables some types in the schema (such as those for attributes, collections, and relationships) to be defined parametrically in terms of other types, which promotes generality, consistency, and reusability of schema elements.
Package Attributes defines specific types of attribute. The basic attribute is just a name-value pair that is associated to an object. (More strongly-typed subtypes of attribute have fixed names, value types, attributed-object types, or combinations of these.) Attributes are one of the main types of design data, and they are important for change management because they can represent the status or state of design elements (such as version number, verification level, or timing characteristics).
Package Collections defines types of collections, including collections with varying degrees of structure, typing, and constraints. Collections are important for change management in that changes must often be coordinated for collections of design elements as a group (e.g., for a work package, verification suite, or IP release). Collections are also used in defining other elements in the schema (for example, baselines and change sets).
The package Relationships defines types of relationships. The basic relationship type is an ordered collection of a fixed number of elements. Subtypes provide directionality, element typing, and additional semantics. Relationships are important for change management because they can define various types of dependencies among design data and resources. Examples include the use of macros in cores, the dependence of timing reports on floor plans and timing contracts, and the dependence of test results on tested designs, test cases, and test tools. Explicit dependency relationships support the analysis of change impact and the efficient and precise propagation of changes,
The package Specifications defines types of data specification and definition. Specifications specify an informational entity; definitions denote a meaning and are used in specifications.
Package Resources represents things (other than design data) that are used in design processes, for example, design tools, IP, design methods, and design engineers. Resources are important for change management in that resources are used in the actions that cause changes and in the actions that respond to changes. Indeed, minimizing the resources needed to handle changes is one of the goals of change management.
Resources are also important in that changes to a resource may require changes to design elements that were created using that resource (for example, when changes to a simulator may require reproduction of simulation results).
Package Events defines types and instances of events. Events are important in change management because changes are a kind of event, and signals of change events can trigger processes to handle the change.
The package Actions provides a representation for things that are done, that is, for the behaviors or executions of tools, scripts, tasks, method steps, etc. Actions are important for change in that actions cause change. Actions can also be triggered in response to changes and can handle changes (such as by propagating changes to dependent artifacts).
Subpackage Action Definitions defines the type Action Execution, which contains information about a particular execution of a particular action. It refers to the definition of the action and to the specific artifacts and attributes read and written, resources used, and events generated and handled. Thus an action execution indicates particular artifacts and attributes that are changed, and it links those to the particular process or activity by which they were changed, the particular artifacts and attributes on which the changes were based, and the particular resources by which the changes were effected. Through this, particular dependency relationships can be established between the objects, data, and resources. This is the specific information needed to analyze and propagate concrete changes to artifacts, processes, resources.
Package Baselines defines types for defining mutually consistent set of design artifacts. Baselines are important for change management in several respects. The elements in a baseline must be protected from arbitrary changes that might disrupt their mutual consistency, and the elements in a baseline must be changed in mutually consistent ways in order to evolve a baseline from one version to another.
The final package in Figure 2 is the Change package. It defines types that for representing change explicitly. These include managed objects, which are objects with an associated change log, change logs and change sets, which are types of collection that contain change records, and change records, which record specific changes to specific objects. They can include a reference to an action execution that caused the change
The subpackage Change Requests includes types for modeling change requests and responses. A change request has a type, description, state, priority, and owner. It can have an associated action definition, which may be the definition of the action to be taken in processing the change request. A change request also has a change-request history log.
An example of the schema is shown in Figure 3. The clear boxes (upper part of diagram) show general types from the schema and the shaded boxes (lower part of the diagram) show types (and a few instances) defined for a specific high-level design process project at IBM.
Click to enlarge
Figure 3. Example of change-management data
The figure shows a dependency relationship between two types of design artifact, VHDLArtifact and FloorPlannableObjects. The relationship is defined in terms of a compiler that derives instances of FloorPlannableObjects from instances of VHDLArtifact. Execution of the compiler constitutes an action that defines the relationship. The specific schema elements are defined based on the general schema using a variety of object-oriented modeling techniques, including subtyping (e.g., VHDLArtifact), instantiation (e.g., Compile1) and parameterization (e.g. VHDLFloorplannable ObjectsDependency).
5. USE CASE IMPLEMENT CHANGE
Here we present an example use case, Implement Change, with details on its activities and how the activities use the schema presented in Section 4. This use case is illustrated in Figure 4.
Click to enlarge
Figure 4. State diagram for use case Implement Change
The Implement Change use case addresses the modification of an existing design element (such as fixing a bug). It is triggered by a change request. The first steps of this use case are to identify and evaluate the change request to be handled. Then the relevant baseline is located, loaded into the engineer’s workspace, and verified. At this point the change can be implemented. This begins with the identification of the artifacts that are immediately affected. Then dependent artifacts are identified and changes propagated according to dependency relationships. (This may entail several iterations.) Once a stable state is achieved, the modified artifacts are verified and regression tested. Depending on test results, more changes may be required. Once the change is considered acceptable, any learning and metrics from the process are captured and the new artifacts and relationships are promoted to the public configuration space.
This paper explores the role of comprehensive change management in SoC design, development, and delivery. Based on the comments of over thirty experienced electronic design engineers from across IBM, we have captured the essential problems and motivations for change management in SoC projects. We have described design scenarios, highlighting places where change management applies, and presented a preliminary schema to show the range of data and relationships change management may incorporate. Change management can benefit both design managers and engineers. It is increasingly essential for improving productivity and reducing time and cost in SoC projects.
Contributions to this work were also made by Nadav Golbandi and Yoav Rubin of IBM’s Haifa Research Lab. Much information and guidance were provided by Jeff Staten and Bernd-josef Huettl of IBM’s Systems and Technology Group. We especially thank Richard Bell, John Coiner, Mark Firstenberg, Andrew Mirsky, Gary Nusbaum, and Harry Reindel of IBM’s Systems and Technology Group for sharing design data and experiences. We are also grateful to the many other people across IBM who contributed their time and expertise.