Comparison of Modeling Systems

As part of our modeling research we have identified several key features and abstractions that work together to create a powerful modeling system that allows rapid modeling of systems, specifications that clearly convey what is being modeled, and creation of libraries of reusable components. Below is a table that summarizes these features and outlines, among a selection of systems, which systems have these features and which systems do not.

Comparison of Modeling System Features
	LSE	SystemC	Asim	Verilog	VHDL
Flexible MoC	Y	Y	N?	Y	Y
Optimizable/Analyzable MoC	Y	N	?	N	N
Data Abstraction	Y	Y	Y	N	C
Component Polymorphism	Y	C	C?	N	N
Component Computation Customization	Y	N	Y	N	N
Control Abstraction	Y	N	N?	N	N
Parametric Scalability	Y	N	?	N	N
Parametric Composition	Y	Y	?	C	N
Data Collection Abstractions	Y	N	?	C	C
Compile-time Knowledge of Structure	Y	N	N?	Y	Y

Table Key

Y - System contains this feature.
N - System does not contain this feature.
C - Abstraction is cumbersome to create but can be created in the system.
? - The system may have this feature, not enough information is available to decide.
Y? - The system likely has this feature, but not enough information is available to know for sure.
N? - The system likely does not have this feature, but not enough information is available to know for sure.
C? - The system likely has this feature and it is also likely to be cumbersome to use, but not enough information is available to know for sure.

Flexible MoC: A Model of Computation (MoC) is flexible (for our purposes) if it does not force the partitioning of components based on I/O dependences, timing, or connection pattern. A more detailed discussion is available here.
Optimizable/Analyzable MoC: It is a tremendous advantage if the model of concurrency (MoC) permits optimization and analysis. Discrete Event models can be difficult to analyze to generate static schedules or to determine timing properties of the system for verification. Other models may be better suited to this, but it is important that they do not limit flexibility. More information on model of concurrency requirements can be found here.
Data Abstraction: Data abstraction is simply the abstracting of types from their low level bit representation.
Component Polymorphism: Polymorphic components are components whose data types are parameterized. This greatly improves the flexibility and reusability of components. More information is available here.
Component Computation Customization: Component Computation Customization is a mechanism by which users of a component can customize how a value is computed. More information can be found here.
Control Abstraction: The relative timing of operations is managed by the control logic. Often, designers wish to experiment with changing the timing of operations in the machine. Without control abstraction, the designer must deal with many tedious changes to the control logic. Building an ideal control abstraction is a difficult problem but partial steps toward a good abstraction can be made. More information is available here.
Parametric Scalability: Parametric scalability is a property of components in a system that allows the bandwidth, or number of requests a component can support, to be scaled on a use-by-use basis. More information can be found here.
Parametric Composition: Components should be parameterizable. Components composed of other components should also be parameterizable. However, in a structural system, function is specified via structure and thus a composite component should have parameters that can control its internal structure. More information is available here.
Data Collection Abstractions: In order to allow changes to a model without having to reason about data collection mechanisms, and in order to allow different types of instrumentation on a single model, the data collection mechanism should be separate from the modeling system. Data Abstractions permit this. More information on this abstraction can be found here.
Compile-time Knowledge of Structure: In order for the structure of a model (i.e. block instantiations and interconnections) to be used to lower the overhead of reuse through parameter inference and type inference, the structure must be known at compile time. Common mechanisms of providing the other features listed above often preclude this possibility. More information can be found here.