Performance Modeling
OMNEST is a component-oriented network simulation framework. The generic architecture of the simulator allows OMNEST to be applied to various problem domains where complex behavior needs to be simulated with high performance; for example protocol modeling, simulation of hardware architectures and computer networks.
Classic performance models are built from more-or-less standardized
components that have relatively simple behavior: queues, resource
allocation/deallocation, splitting and joining jobs, updating variables,
etc. If your model is of this type, you probably don't need OMNEST
because you cannot make use of its competitive advantage (simulating
complex behavior with high performance). However, if you need to simulate a
complex, real-world system, chances are you cannot
express its behavior with standardized performance modeling components
alone.
Today's technology is incredibly complex, and it can be a difficult task to find the right abstraction level for the simulation model. If the model is too detailed, it takes a long time to develop and validate, and it also runs slower. If it is too simple and ignores something important, your results may not have anything to do with the real system. It is a valid approach to start the model simple (so you have quickly have some initial results), and refine it gradually by adding details, depending on what you learn along the way about the system.
The OMNEST Approach
We provide you with building blocks to create an initial performance model with the "classic" approach, so that you quickly have approximate results. Then you can start refining the original model, and add more details. You can build upon our blocks using C++ class inheritance, or you can just copy and modify their sources. Our performance modeling library can thus give you a head-start for building detailed, high-performance simulation models.
The fact that OMNEST models are written in C++ also allows you to seamlessly integrate "foreign" C or C++ code into the simulation, such as production code from your company's products or an open-source protocol implementation.
Why not <name-of-another-simulation-package>?
Why not choose a simulation package based on Java or a special-purpose simulation language, or a "no-programming" GUI simulation software? One of these other solutions may work for you; however, consider this:
If your model cannot fit within the natural concepts of the simulation package, performance will suffer. And maybe you will also struggle implementing the model. If your model is behaviorally complex, you will need to write additional code because you cannot express behavior using the building blocks provided by the tool alone. Special-purpose simulation languages are often not very good at expressing general programming concepts or when they do, performance is often not as great as with C/C++. Performance may also be a problem with Java code. You need to consider what performance you want to get out of your simulator.
Do you have C/C++ code that you may want to integrate into the simulation? If you choose a non-C/C++ based simulator, you may still be able to integrate your C/C++ code into the simulation, but it is never as easy as when the whole simulation is already in C++ as in OMNEST.
Do you expect that you'll need to interface your simulation with external systems? Connect to other simulators, perform real-time hardware-in-the-loop simulations, and so on. If so, then double-check if the simulation package allows it. With OMNEST, the entire simulator is completely open for extension via C/C++, so you know for sure that you will be able to do whatever you need to do.
Does your simulation potentially involve data communication or computer networks? When modeling an IT system (e.g. a SOA application), network performance and the behavior of network protocols may be an important factor in the overall performance, so that they need to be simulated explicitly at some point. (For example, TCP can exhibit very complex stateful nonlinear behavior when it experiences congestion.) In such simulations, the large body of protocol simulation frameworks that exist for OMNEST can be very useful, as they can be used as building blocks in your simulation.
Why not write a monolithic C program?
You may end up reinventing the wheel. Simulation time management, reading parameters from file, random number generation, recording results and plotting results, etc. are tasks that OMNEST solves, and solves them well. So why would you spend time implementing them from scratch?
Debugging and validation will also take longer. Why? OMNEST provides tools to step through, animate, trace and visualize a simulation model using a graphical runtime environment. An unrivalled feature of OMNEST is that it can visualize simulation execution on interactive sequence charts drawn from recorded log files -- this feature alone can be indispensable for debugging and validating nontrivial simulation models.
It will be difficult to reuse the same program for similar simulation projects, or adapt to variations in the current project. OMNEST simulations are composed of modules, which are natural units of reuse, reduce inter-dependencies between parts of the model, and also make graphical editing possible. Compared to using plain C or C++, OMNEST modules make your simulation models a lot easier to reconfigure and to adapt to your next simulation project.