The debate over the correct approach to designing SoC based systems is fierce. Is it a traditional register transfer level (RTL) process? Or is it a high-level synthesis of the C language behavior model? What about reducing the intellectual property (IP) reuse of code generation? Each expert has his or her own perspective on how the design team should go from requirements analysis to manufacturing implementation. Each point of view is based on its own preferences, past experience, or – the EDA supplier itself will consider product availability. But in many real-world environments, all of these ideas may be irrelevant. The reason is simple: most system designs - according to a recent study on embedded.com, 55% of designs are not new designs. They are actually modifications to certain types of existing designs. This fact means that the actual design process depends not only on the advice of some method experts, but also on the changing characteristics of the requirements and the data that the design team can get. The result may be from a form-driven revision process, to thorough modifications, and even unpredictable changes. Often, the results are actually redesigned for the entire system: not because of the scope of the change, but because there is no reuse plan, and there is no way to manage the changes. In this article, we will discuss with method experts and actual designers, what happens when system requirements change, and whether there is a consistent approach. Then, we will apply this working method in several real design environments, and use it to suggest what design process should be used and how to make it work better. Some classification Derivative designs appear in at least three different environments (Figure 1). Most notably, a series of changes in demand for existing designs define new projects: for example, new features, new peripherals, or new performance metrics. Figure 1. Derived design classification And there are at least two other categories. One is to use platform design, such as Google's Android platform. Frank Schirrmeister, Director of Cadence's System Development Kit Product Marketing Group, highlighted Texas Instruments' Open Multimedia Application Platform (OMAP), which is a good example. He observed that the extended platform defined by the OMAP platform contains almost all the systems that can be thought of in the application domain. The design team produces some kind of instantiation by taking unused modules out of the platform, and in some cases, re-optimizing the resulting design. The third category is related: the use of reference designs. This process is actually an example of derivative design, but it is an important method. It is different from modifying an existing design by itself, and it is different from applying a platform. For the three cases, only the first one can be classified as a derivative design. Platform-based design and reference-based design are generally considered new designs. But all three have a common characteristic. They start with an already completed design and then compare the new design requirements against existing specifications. They find differences from existing designs and then implement them. The first step: What changes? These design processes start with some new requirements. The first step in each process is to find the difference between the new requirements and the existing designs. In theory, this is a rigorous process. We can find these differences by comparing the initial requirements document with the revised requirements document. But in many cases, the design team cannot use the original, current, and correct requirements documents of the existing design. We will discuss these situations later in this article. The next step in our theoretical process is to divide each demand change into three categories: behavior, structure, and parameters. Behavioral changes - changes in system functionality, which is the most common, according to embedded.com research, which occupies more than half of the derivative design. Interestingly, the current automated design tools provide little support for them, just provide some forms. In contrast, structural changes indicate certain changes to the system hardware or software: for example, changes to the operating system, addition or removal of hardware modules, or changes in the interconnection between modules. In some applications, such as communication infrastructure, system I/O can change frequently. Kevin Weldon, Altera's design work expert, commented: "We have been working with our customers to achieve their target frequency. But now, we see more changes happening in I/O. Customers want to make sure that I/O does not occur. block." Parameter changes indicate the amount of change in measurable metrics: for example, response time, bandwidth, supply current, and material cost. It is easy to find these changes through the requirements documentation of certain hardware and software modules until they are meaningful, but it is difficult to track. Find relevance In an ideal environment, from the perspective of several compatibility, there is one of the earliest designs - this is the design from which we get new systems. Not only do we have formal requirements documentation, but we also have behavioral models—possibly in the form of more abstract C code and session-level versions. We also have a modular architecture model of hardware and software. For actual implementation, there will be RTL and software code. In this environment, the next step is to observe. We modify behavioral models to meet changes in behavioral needs. Changes in structural requirements can trigger adjustments to IP or interconnects, even software functions. Changes in parameters can result in revisions to the implementation level code. In each case, we have traceability and design-independent files to determine how the adjustments we make affect other parts of the design (Figure 2), so for example, if we modify the definition of the data structure or a part of the design The bandwidth of the signal, then, we will know which areas of the design are affected by these modifications. The tool will help us save all the documentation from requirements to implementation. Figure 2. Traceability simplifies the conversion of requirements to work statements After each adjustment, we re-simulate at the appropriate level of abstraction to verify that the modified design is now meeting the new requirements. Then, pass this modification to the underlying abstraction layer and re-optimize until our new design is validated. Schirrmeister pointed out that this idealized process relies heavily on two other sets of data, but there is no guarantee that it can be used. The first is to use the scene. In the correct usage scenario, we can limit the validation of the modified design, especially the modes and inputs that are important to the user. If the model is not used, we need to make sure that the new design meets the existing and modified requirements in all possible real-world environments. Second is enough test benches for the entire system and key subsystems. In practice, the test bench reflects the need that human language documents cannot be represented. Many design teams recognize this shortcoming and re-establish the system test bench, which is as large as the system design itself – if it does not provide data on key components such as third-party SoCs, it will be even larger. 4 Outlets EU Socket,EU Power Socket USB,EU Power Socket Dongguan baiyou electronic co.,ltd , https://www.dgbaiyou.com
