Access Official Technical PDF

Share Summary:LinkedInEmail

As digital systems take on more functions and execute more operations concurrently, describing every implementation detail directly can make design and verification harder. Scenario-based hardware synthesis offers another route: describe the behaviours a system must support, then compose those behaviours into a hardware implementation. Research in this area explores how formal models and algorithms can make that process practical for complex control and data-processing systems.

The approach is relevant to engineers working with control architectures, accelerators and systems whose operations depend on events or data conditions. Its central idea is to treat a system not as one monolithic behaviour, but as a set of scenarios that can be examined and combined.

Why model a system as scenarios?

A scenario describes a possible behaviour of a system through operations and the relationships between them. For a controller, scenarios might represent different instruction behaviours or operating sequences. For a data-processing pipeline, they can describe which operations take place and how data moves between them.

This representation raises the level of abstraction. Engineers can focus on what the system does before committing to a particular circuit structure. The resulting models can also provide a basis for formal verification: the design can be checked against its behavioural specification rather than assessed only through a limited set of input-output tests.

Concurrency is an important part of the challenge. In a concurrent system, some operations may proceed independently while others must wait for specific events or results. Models based on partial orders, Petri nets and dataflow structures can express these relationships, helping preserve the intended behaviour when scenarios are translated into hardware.

Scenario-based hardware synthesis and composition

Listing every scenario is only the first step. The scenarios must be composed into a system specification that includes both the behaviours and a way to select among them. One straightforward approach would implement each scenario separately and add selection logic. That can duplicate functionality shared across scenarios.

An alternative is to compose scenarios so that common operations or resources can be shared. This can produce a more compact model from which engineers can derive an implementation. Compactness is not itself a guarantee of better physical results, but the research evaluates whether scenario composition can support more efficient hardware implementations.

One methodology uses Conditional Partial Order Graphs (CPOGs). A partial order represents operations and their dependencies within a scenario; a CPOG combines scenarios and uses conditions to identify which behaviour applies. The work describes a composition algorithm designed to handle specifications with hundreds of scenarios. Unlike earlier approaches discussed in the report, it also supports composition constraints—useful when some design choices must be restricted, including to accommodate existing IP blocks.

In the reported experiments, the heuristic mapping approach handled specifications comprising hundreds of scenarios with an area overhead of 5% compared with exact algorithms. This is a result of the evaluated approach, not a general guarantee for every design or implementation flow.

Modelling reconfigurable dataflow

Scenario composition also applies to dataflow-oriented systems. Static dataflow structures describe how operations exchange data, but the work identifies a limitation when a system needs to change which data paths execute. Its proposed Dataflow Structures (DFS) formalism combines static structures to represent dynamically reconfigurable behaviour, including operations that execute conditionally.

This matters when a system must support different processing configurations rather than one fixed path. A scenario-based model can make those alternatives explicit and provide a route from behavioural description to implementation. The research validated this direction with a prototype asynchronous pipeline for ordinal pattern encoding, an algorithm used to detect repetitive patterns in data streams. The prototype was designed to support a range of computations through runtime reconfiguration and to operate under unstable supply voltage conditions.

Applications: control logic and acceleration

The techniques were evaluated across several case studies, illustrating different uses for scenario-based design:

  • Control synthesis: Processor instruction sets and other control architectures can be represented as collections of behaviours and composed into controller implementations.
  • Asynchronous processing: Dataflow scenarios can describe reconfigurable pipelines, with a fabricated prototype used to investigate the approach.
  • Graph analysis: An FPGA accelerator was developed for computational drug discovery, modelling protein-interaction networks and calculating shortest paths.

For the drug-discovery case study, the reported accelerator was up to three orders of magnitude faster than conventional software implementations. That figure applies to the evaluated prototype and workloads; it should not be read as a general performance expectation for FPGA acceleration.

Practical considerations for engineering teams

Scenario-based methods do not remove the need for careful system definition. Teams still need to identify relevant behaviours, specify dependencies and determine how scenarios are selected. The choice of formalism also matters: a controller, a dataflow pipeline and a network-analysis accelerator may require different ways of representing concurrency and data movement.

For engineering teams considering this approach, useful questions include:

  • Can the system’s behaviour be divided into a manageable set of scenarios?
  • Which operations or resources are shared across those scenarios?
  • Are there constraints on how scenarios may be combined, such as requirements to reuse existing IP?
  • Which properties need to be verified before implementation?
  • Does the target design require dynamic reconfiguration or asynchronous operation?

These questions help connect behavioural modelling to implementation needs, rather than treating scenario definition as an isolated specification exercise.

Conclusion

Scenario-based hardware synthesis provides a structured way to describe concurrent systems through their behaviours and compose those behaviours into hardware models. Research on CPOGs, Dataflow Structures and Process Windows shows how scenario-oriented methods can support composition, reconfigurable dataflow and system understanding. For automation engineers and technical decision-makers, the practical value lies in making complex behaviour explicit and creating a formal path from specification toward synthesis and verification. The results are promising across control and acceleration case studies, while remaining specific to the models, algorithms and prototypes evaluated.

Access Official Technical PDF

About The Author