Ron Wilson, Altera Corporation
The debate over the design of correct methods based on SoC systems is fierce. Is it a traditional register transfer level (RTL) flow or an advanced synthesis of the C language behavior model? What about IP reuse methods that reduce code generation?
Every expert has their own opinions on how the design team should go from requirements analysis to manufacturing implementation. Each point of view is based on their own preferences, past experience, or -- EDA vendors themselves consider product availability. But in many real environments, all of these ideas may be irrelevant.
The reason is simple: Most system designs—according to a recent study on the website embedded.com, 55% of designs are not new designs. They are actually modifications to a certain type of existing design. This fact means that the actual design process depends not only on the recommendations of certain method experts, but also on the changing characteristics of the requirements and the data that the design team can obtain. The result may be a form-driven revision process, thorough changes, or even unpredictable changes. Often, the result is actually a redesign of the entire system: not because of the scope of the change, but because there is no reuse plan and no way to manage the changes.
In this article, we will discuss with method experts and actual designers. When there is a change in system requirements, what will happen and whether there is a consistent method? Then, we will apply this method of work in several real design environments and use it to suggest what kind of design process should be used and how to make it work better.
Some categories
Derived designs appear in at least three different environments. The most obvious is that a series of changes in the requirements of existing designs define new items: for example, new features, new peripherals, or new performance indicators.
Figure 1. Derived design categories
There are at least two other categories. One is the use of platform design, such as Google's Android platform. Frank Schirrmeister, Group Director of Cadence's System Development Kit Product Marketing, specifically pointed out TI's Open Multimedia Applications Platform (OMAP), which is a good example. He observed that the extended platform defined by the OMAP platform contains almost all systems that can be thought of in the application domain. The design team creates instantiations by taking unused modules out of the platform and, in some cases, re-optimizing the resulting design.
The third category is related: Use a reference design. This process is actually an example of derivative design, but it is an important method. It is different from modifying existing designs and is not the same as applying a platform.
For these three cases, only the first one can be classified as a derivative design. Platform-based designs and reference-based designs are generally considered new designs. But all three have common characteristics. They begin 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 begin with some new requirements. The first step in each process is to find the differences between new requirements and existing designs. In theory, this is a rigorous process. We can find these differences by comparing the original requirements document with the revised requirements document. But in many cases, the design team cannot use the original, current, correct requirements document 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. Changes in behavior - changes in system functions, which are the most common, according to embedded.com research, it accounts for more than half of the derived design. Interestingly, currently automated design tools provide little support for them, but provide some forms.
In contrast, structural changes point to certain changes in the system hardware or software: for example, changes to the operating system, additions or removals of hardware modules, or changes in the interconnection between modules. In some applications, such as communications infrastructure, system I/O can change frequently. Altera design work expert Kevin Weldon commented: “We have been working with customers to achieve their target operating frequency. But now, we see more changes in I/O. Customers want to be sure that there will be no I/O block."
Changes in parameters use measurable indicators to indicate the amount of change: for example, response time, bandwidth, supply current, and material cost. Through the documentation of the requirements of some hardware and software modules, it is easy to find these changes, but it is difficult to track.
Find relevance
In an ideal environment, from a few compatible points of view, there is one earliest design—this is the design from which we derive the new system. We don't just have a formal requirements document, but also a behavioral model—it may be provided in more abstract C-code and session-level versions. We will also have module-level architecture models of hardware and software. For the actual implementation, there will be RTL and software code.
In this environment, the next step is observation. We modify behavioral models to meet changes in behavioral needs. Changes in the structure requirements will trigger adjustments to the IP or interconnection, and even software functionality. Changes in the parameters will result in the revision of code at the implementation level.
In each case, we will have traceable and design-independent files to determine how the adjustments we make will affect other parts of the design. So, for example, if we modify the definition of the data structure or the bandwidth of a signal in a certain part of the design, Well, we will know that these changes will affect which areas of the design. The tool will help us save all documents from requirements to implementation.
Figure 2. Traceability simplifies the conversion of requirements to work statements
After each adjustment, we will re-simulate at the appropriate abstraction level to verify that the modified design can now meet new requirements. Then, pass this modification to the underlying underlying abstraction layer and re-optimize it until our new design is validated.
Schirrmeister pointed out that this idealized process is very dependent on two other sets of data, but there is no guarantee that the data can be used. The first is the use of the scene. In the correct usage scenario, we can limit the verification of the modified design, especially the modes and inputs that are important to the user. If we do not use the model, we need to make sure that the new design satisfies both existing and modified requirements in all possible real environments.
Followed by enough test stations, for the entire system and key subsystems. In practice, the test bed embodies the needs that human language documents cannot represent. Many design teams recognize this deficiencies and re-establish the system test bench. The scale of this project is as large as the system design itself—it will be even larger if data from key components such as third-party SoCs cannot be provided.
In a real environment
For some designer organizations, our idealized example may not be feasible. Design teams in areas such as automotive, transportation, and civil aviation need to face standards such as ISO 26262 or DO 178B, requiring each unit in the design and test bench to be traceable to the control unit of the requirements document. These design teams can find out which part of the design needs to be tested and even modified to meet the changes in requirements. They can indicate which modules need to be modified in the test bench. This starts with a lot of investment.
However, in most practical designs, traceability of formal requirements is difficult to achieve. The traceability of such projects exists only in the brains of design team members. Even the original designer could say what was causing him to implement a module in some way, but before someone asked him questions, he might have left the company or was not in the industry. We have to question how our ideal scenario is applied in these real environments.
On a platform
Consider how the design team uses the platform design. The platform is generally provided by the SoC vendor and is an extension of the system design, with Android being the obvious exception. The attempts you are trying to make against this architecture are contained in the specification. The concept is very simple. Build your own needs, find some platforms you don't need, and don't use them. Then, optimize other parts as needed to satisfy the parameter constraints.
Figure 3. Remove some of the platforms so that the platform design meets specific needs.
However, this concept also faces some difficulties. First, there is not necessarily a requirements document. Therefore, the team had to guess what the purpose of the platform builder was and whether it met the new requirements. After determining the different points, this is relatively simple. For example, Android can apply to cameras and microphones. If you do not need these, you can remove these functions.
Functional requirements will be more challenging. You may need a camera to capture MPEG4 video. However, do you need four ARM® cores and a DDR3 SDRAM interface? Are users just browsing the web, and do you still need to capture and compress video? The lack of usage models and functional requirements will force you to perform a lot of system-level simulation. Discover which modules actually participate in the work that you need to support.
Schirrmeister observes, “You have to be clear what the new requirements really mean. I once worked on a project where the video processor needed to use the letterbox format. It sounded simply to increase the output format. What we didn’t realize at first was the system. The working method, mailbox format allows us to have very little time to decode each frame, so this has very high performance requirements for the rest of the design. The actual situation is to understand the implications of changing requirements."
Parametric requirements are more challenging. You have to use the chip model to run system simulations on the RTL to determine if the platform meets the required specifications. Moreover, several levels of simulation models, accurate use models, and a large number of test benches are key components of the actual design platform.
Modify last design
Working from the platform, the design team only needs to take the module out of the platform and optimize it to determine that it can meet the demand. But if you work from a previous design, or if it is even more difficult to start working with a third-party reference design, what will happen? The principle remains unchanged. However, in the real environment, the design team generally does not have tracking requirements in the existing design, and may not have a good system or module-level simulation model, or a fully applicable test station. The method depends on the skill.
The challenge begins with finding what changes have been made. According to Stacy Martin, an Altera design expert, "This process is generally in no order. The team looks at the specifications, finds features or interfaces that are inadequate, and then solves these problems."
Now it's a little more complicated. If these changes are contained within the scope of the existing implementation, it can be optimized. It may also exceed the scope of the existing design. Alternatively, without a credible requirements document, the designer should correctly estimate the performance from the system-level model and perform the simulation again to find out what the existing design can achieve. In fact, the team should analyze the existing design implementation in order to regenerate the design's needs. Without proper use of the model and a good test bench, the team will have a significant investment in understanding the needs before starting any redesign.
This is a great challenge. Martin said: "The design team tried to reuse the design as much as possible. However, after trying your best to reuse it, it was found that sometimes it was better to design from scratch."
In a real environment, there are actually different approaches to derivative design. What we are introducing here is only a small part, which is related to the designer's skills in finding changes in demand. The greater the initial designer's investment in reusability - maintain the correct design version at the level of demand, behavior, structure, and implementation; lock in the use model; build adaptive test benches; so that the more real-world derived designs can Close to its ideal form.
Product line engineering
But the real environment is always changing. At present, in certain applications such as military, aerospace, and transportation systems, traceability of requirements has become a contractual clause. Very complex system designs and high-cost one-time SoC design investment will also have this requirement. In many current industries, cost and complexity pressures have changed the structure and methods of system design.
New opportunities mean new chip designs. However, design teams are increasingly inclined to no longer make new designs. The team maintains and continues to re-apply a series of intellectual property cores and complete test benches, occasionally trying new metal masks, and rarely using brand new templates. For every design that is a central hardware/software IP-derived application, it is actually a product line project.
Success depends on the automation of design reuse. The degree of IP assembly also depends on methods that can be strictly traced to the requirements. Traces to testbench modules, silicon IP blocks, and software modules are easily transferred from previous system-level behavioral models to detailed silicon simulation and software debugging. This is also the view of Meg Selfe, IBM's vice president of intelligent physical infrastructure.
Selfe said that the product line engineering infrastructure spans three areas - tools, processes and best practices. Among them, it is surprising that there is generally no shortage of tools. The Selfe report states: "We usually work with organizations that have a lot of tools. The difficulty is that we don't connect tools through a consistent platform, so there are manual steps in the process. Manual steps lead to interruptions."
Selfe emphasizes that when moving from traditional SoC design to product line engineering – not only the next design needs but also how the company operates. Selfe suggested "determine what you want to achieve in your design process, find the cause, and correct it."
She noted that at present, the biggest deficiency in the traceability design process is between requirements and test benches. In the future, in the early system modeling culture, the difference between the system model and its test bench will become smaller and smaller. The complete system model in the target application environment becomes a test bench for a detailed model of a subsystem. Changes in demand will be associated with all affected modules in the design and test bench. Test coverage standards translate directly into an accurate estimate of the design requirements coverage. The design will increase investment in automatically focusing on meeting changes in demand, rather than re-establishing parts of the design that have not changed, nor will it duplicate the functionality already existing in the IP.
100% authentic best 18650 cells, below is our regular inventory list:
authentic sony li ion battery cells
US18650VTC6 3000mAh 15A/20AdischargeUS18650VTC5A 2500mAh 30Adischarge
US18650VTC5 2500mAh 20Adischarge
US18650VTC4 2100mAh 30Adischarge
US18650V3 2200mAh 10Adischarge E bike cells
US18650VC7 3400mAh 5A/8Adischarge
US18650NC1 2900mAh 10Adischarge E bike cells
US454261A8T 1590mAhlipo cells
Original Sanyo cells:
NCR18650BF 3400mAh
NCR18650GA 3450mAh 10AdischargeE bike cells
UR16650ZTA 2500mAh
UR18650ZTA 4.35V 3000mAh
UR18650FJ 2100/2200mAh red top
UR18650FM 2500/2600mAh blue head
UR18650FK 2300/2400mAh green top
UR18650ZY 2450/2550mAh Made In Japan
UR18650ZY 2450/2550mAh
UR18650AY 2150/2250mAh white head
UR14500P 830mah
UR18500F(K) 1620/1700mAh
UR18650NSX 2600mAh 20Adischarge
UF103450PN 1880/2000mAh with fuse
UF103450PN 1880/2000mAh no fuse
UF463450F
UF703450 1430/1480mAh
UF653450 1250/1300mAh
UF624447F 1530mAh
UF553450ZP 1150/1200mAh
UF553450ZP 1150/1200mAh
UF553443ZU 1000mAh
UF463048F
UF553436G
Authentic Panasonic cells:
NCR18650B3 3400mAh
NCR18650A 3100mAh
NCR18650BM 3200mAh
NCR18650 2900mAh
NCR18650PF 2900mAh 10AdischargeE bike cells
NCA103450 2350mAh no breaker
NCA903864 3120mAh
NC-1900SCR
NCR18500A 1940/2040mAh
NCR18650GA 3450mAh 10AdischargeE bike cells
Original Samsung li ion cells:
INR18650-25RM 2500mAh 20Adischarge
INR18650-25RM 2500mAh 20Adischarge
INR18650-25R 2500mAh 20Adischarge,
INR18650-20RM 2000mAh 22Adischarge
INR18650-30Q 3000mAh 15Adischarge
ICR18650-30B 4.35V 3000mAh
INR18650-35E 3500mAh 10Adischarge
INR18650-29E 2900mAh 8.25Adischarge
INR18650-32E 3200mAh 10Adischarge
ICR18650-22P 2150mAh 10Adischarge
ICR18650-22PM 2150mAh 10Adischarge,
ICR18650-22F 2200mAh
ICR18650-22FM 2200mAh
ICR18650-26JM 2600mAh
ICR18650-26FM 2600mAh
ICR18650-26HM 2600mAh
Original LG cells:
INR18650HE4, 2500mAh 20Adischarge
INR18650F1L, 3400mAh
ICR18650S3, 2200mAh,
ICR18650B4/B4L, 2600mAh
ICR18650MF1/MF2,2200mAh,10Adischarge
ICR18650M26,2600mAh, 10Adischarge
INR18650MG1 2900mAh 10Adischarge
INR18650MH1 3200mAh 10Adischarge
INR18650MJ1 3500mAh 10Adischarger
18650 Battery,Best 18650 Battery,18650 Lithium Battery,18650 Lithium Ion Battery
Asarke Industry Co., Limited , https://www.asarke-industry.com