Access Official Technical PDF

Share Summary:LinkedInEmail

Embedded system design is increasingly a system-level challenge. Devices that once relied on relatively straightforward computing elements may now use application-specific, heterogeneous multiprocessor systems-on-chip (MPSoCs). For industrial automation engineers and technical decision-makers, the broader lesson is that hardware and software cannot always be designed as isolated parts: system behavior, timing, communication and implementation choices need to be considered together.

Growing application demands, tighter constraints and rising chip design costs make traditional implementation approaches harder to manage. System-level design addresses this complexity through formal models and design automation methods that help teams specify, simulate, analyze and refine a complete system before committing to its implementation.

Why system-level design matters

An embedded system combines computation and communication across hardware and software boundaries. As the number of processing elements and interactions increases, it becomes more difficult to understand how the whole system will behave by looking only at individual components. Parallel execution adds another challenge: the design must account for concurrency as well as the order and timing of events.

System-level methods establish a higher-level description of the intended system. That description can be used to reason about behavior and implementation choices before detailed hardware and software are finalized. The goal is not simply to produce a model, but to create a disciplined path from specification through analysis and synthesis.

This approach is relevant wherever embedded computing must meet defined functional or timing constraints. It gives engineering teams a way to discuss system behavior at a level that connects application requirements to architectural decisions, while retaining a route toward implementation.

Modeling behavior with languages and models of computation

System-level design languages (SLDLs), including SpecC and SystemC, provide ways to describe systems at an appropriate level of abstraction. The language is only part of the method: designers also need a clear account of how processes execute, communicate and interact over time.

Models of computation (MoCs) provide that account. They define rules for representing system behavior, including concurrency and time. The choice of model affects how a design is expressed and analyzed. Common approaches include:

  • Finite state machines (FSMs): Represent behavior as states and transitions, making state-dependent operation explicit.
  • Process networks: Describe a system as processes that operate concurrently and exchange information.
  • Dataflow models: Represent computation through the movement of data between operations.

Other modeling approaches include discrete-event and synchronous-reactive semantics, as well as hierarchical and concurrent state machines. These are not interchangeable notations for the same problem. Selecting a model involves choosing a way to express the system’s behavior and the relationships that matter for its analysis.

Refining a model toward an implementation

A system description typically becomes more detailed as design progresses. System refinement is the process of moving from an abstract specification toward a model that reflects implementation decisions. This can include refining computation, communication and the platform on which the system is expected to run.

For computation, source-level and host-compiled modeling offer ways to represent processing at different levels. Platform modeling can account for elements such as processors and operating systems. The appropriate level of detail depends on the question being asked: a broad architectural decision may not require the same model detail as an analysis of a particular implementation choice.

Communication can also be refined progressively. Transaction-level modeling (TLM) represents communication through transactions rather than requiring every low-level signal interaction to be described. This can support system simulation while keeping the model focused on exchanges between components. As the design advances, communication and computation models can be made more specific.

Using synthesis and exploration to evaluate choices

System-level synthesis connects a model to implementation decisions. The relevant methods include partitioning, scheduling and mapping: deciding how work is divided, when tasks execute and how they are assigned to available resources. In multiprocessor systems, these decisions are closely related because the organization of computation affects how the system can be scheduled and mapped.

Design space exploration provides a structured way to consider alternatives and estimate their consequences. Rather than treating an initial architecture as fixed, teams can examine different design decisions against the system’s requirements and constraints. This is particularly important when multiple implementation options must be balanced, though the quality of the evaluation depends on the models and estimates available.

A system-level workflow may therefore include:

  1. Specify the system using a suitable language and model of computation.
  2. Simulate and analyze behavior at the chosen level of detail.
  3. Refine computation, communication and platform assumptions.
  4. Explore partitioning, scheduling and mapping alternatives.
  5. Synthesize or implement the selected design across hardware and software.

What this means for automation engineering teams

The methods described for embedded MPSoCs also offer a useful way to think about complex automation-related embedded designs. They encourage teams to make behavior and assumptions explicit before implementation details obscure them. They also provide a shared framework for discussing software, processing resources and communication as parts of one system.

For engineering organizations, the practical consideration is to match modeling detail to the decision at hand. A model should be clear enough to support meaningful analysis, but its assumptions must remain visible. Teams also need to understand the selected model of computation and how it represents timing, concurrency and communication; otherwise, simulation results may not address the questions the design team needs answered.

Conclusion

Embedded system design increasingly depends on methods that can manage complexity across hardware and software. System-level languages and models of computation make behavior explicit, while refinement, transaction-level modeling, synthesis and design space exploration provide a structured route from specification toward implementation. For industrial automation teams evaluating embedded architectures, these practices help organize technical decisions around the behavior of the complete system—not just its individual components.

Access Official Technical PDF

About The Author