GENERAL
- Hierarchical, component-based modeling
Models are built from reusable, self-contained components; this feature
provides flexibility and reduces maintenance costs. Models are defined
using a high-level declarative language (NED), and can be edited
graphically or in source mode. NED provides packages, inheritance,
interfaces, parametric types, metadata annotation and other features
that allow easy scalability of models.
- C++-based, high performance simulation kernel
Atomic components are programmed in C++, using a well-defined API to the simulation library.
The use of C++, together with the streamlined simulation kernel, provide high event/sec throughput.
- Integrated, extensible Simulation IDE
The Eclipse-based OMNEST Simulation IDE supports all phases of designing, running and evaluating
simulations. The IDE is extensible with 3rd party software from the Eclipse Marketplace and other
Eclipse plug-in sites.
- Powerful GUI for tracing, debugging and animating your simulations
Simulations can be run under a graphical interactive runtime environment or a
command-line interface for batch execution. The graphical runtime environment provides
animation and tracing, and lets you peek into objects and variables in the C++ code
while the simulation executes.
- Wide range of applicability
OMNEST/OMNeT++ has proven itself in the simulation of wired and wireless communication networks,
high-level architectural simulation of hardware/software systems, performance modeling
(queueing networks) and other areas.
- Models are self-documenting
The documentation tool generates high-quality documentation from commented model source code, with diagrams, tables and cross-references. Integrates well with the Doxygen C++ documentation tool.
- Responsive and expert support
Your requests are answered directly by the developers, not by tech-support personnel.
PROGRAMMING MODEL AND FACILITIES
- Message passing
Modules communicate primarily by message passing, via connections or direct sending.
Messages may represent jobs, network packets, control information or other entities.
OMNEST provides support for generating C++ message classes (e.g. packet headers)
from compact descriptions. Timers are also represented with messages that a module sends to itself.
- Parameters
Simulation models can be parameterized via module parameters. Module parameters
can carry simple (int, double, string, bool) and compound data types (e.g. XML),
and can be set to values like normal(1.0,0.3) to act as random number sources.
To reduce the amount of configuration needed to parameterize a model, parameters
may have default values, and multiple parameters can be set together by using
wildcard patterns for the parameter's name and location.
- Signals framework
OMNEST provides a signals framework that is used for publish-subscribe
communication among modules, obtaining notification about structural model changes,
exposing statistics, and so on. Signals emitted from a module propagate up to the
root in the module hierarchy, and modules and other code can subscribe to selected
signals at any level.
- Result recording
Model code can record simulation results directly, or expose them as signals and let
the simulation framework take care of recording them in the appropriate form and
level of detail. Results can be recorded as scalars (e.g. the sum, count, average,
other other property of the values), as histograms, as statistical summaries,
or all values as vectors (i.e. time series). Result files can be plotted using
the IDE, or programmatically from GNU R (we have an R package that understands
result files) or other programming environments.
OPENNESS
- Source code is provided
We provide the full source code to increase your understanding of the simulation
framework, to help in debugging, and to enable you to make modifications should it
ever become necessary.
- Open interfaces
All model files and output files are plain text to make it easier for you to process
them with your own custom or 3rd party tools. We also provide command-line tools
and libraries to manipulate them.
- Open-source simulation models
Many open-source, community-supported simulation models and model frameworks are available from omnetpp.org and other websites.
- Extensible
C++ plug-in interfaces are made available to customize various aspects of the simulation kernel:
event scheduling, configuration and model parameterization, result recording and more.
ADVANCED
- Multiple Replications in Parallel
OMNEST lets you speed up steady-state simulations using the Akaroa package.
Akaroa runs multiple replications of the model on nodes of a computing cluster.
- Real-time and hardware-in-the-loop simulation
The simulation kernel supports real-time and hardware-in-the loop simulation
via a plugin interface. A functioning and extensively commented source code
example will help you to quickly implement your own application-specific
hardware-in-the-loop simulation.
- Network emulation capabilities
Available as part of model packages like the INET Framework.
- Parallel simulation
Parallel simulation on clusters or multiprocessors, with MPI and powerful
conservative synchronization. Using named pipes or other communication means
instead of MPI is also possible.
- SystemC integration
Allows for mixing OMNEST and SystemC modules in the same simulation program,
without losing performance. (Co-simulation solutions found in other products
usually incur a significant performance penalty.)
- HLA support
Allows for connecting OMNEST with other simulators via HLA / IEEE 1516.
- Embeddable simulation kernel
The simulation kernel can be embedded into 3rd party products as a C++ class library.
See our References for companies that have already done so.
Read more