710.omnetpp_r
Discrete Event Simulation
710.omnetpp was submitted to the SPEC CPU v8 Benchmark Search Program by Marcel Marek.
The benchmark simulates various network and queueing scenarios using the OMNeT++ discrete event simulation framework ([1]www.omnetpp.org), a generic and open simulation framework. OMNeT++ is widely used for communication network simulations, offering a highly modular and flexible architecture. This benchmark provides a comprehensive view of network performance across different configurations.
Key scenarios modelled in the benchmark
| Scenario | Short Description |
| Random Mesh | A large, randomly connected mesh network simulating gigabit Ethernet traffic. Hosts are interconnected randomly, and the model tracks performance metrics such as end-to-end delay and hop count across the network. |
| OneFifo | A single queue model that simulates job processing times and queue capacity under a specified workload. |
| TandemFifos | A multi-queue model that simulates jobs passing through a series of queues, capturing performance at different processing stages. |
| Closed Queueing Network (SmallCQN) | A small, closed queuing network with jobs circulating through multiple queues designed to model complex network behaviour and resource sharing. |
| Ring | A ring network of servers, modelling job processing and server interaction in a closed-loop system. |
| Terminal | A model of a flight terminal, simulating various passenger processes such as check-in, boarding, and security screening. |
| CallCenter | A simulation of a call center with jobs arriving at random intervals. It models dynamic prioritization and queue handling based on call type and urgency. |
| ForkJoin | A network that splits jobs into multiple parallel tasks, which are then joined after processing, simulating distributed job handling. |
| ResourceAllocation | A network where multiple queues share a common resource, representing a scenario where multiple jobs compete for limited processing capacity. |
| AllocDealloc | A dynamic resource allocation model where resources are allocated and deallocated to queues based on job arrival rates and processing demands. |
This benchmark is designed to assess network performance, resource utilization, and the behaviour of complex queueing systems under various conditions. Each scenario highlights different network dynamics and system efficiency aspects, making it useful for performance analysis and optimization.
| Scenario | Input Description | Key Parameters |
| Random Mesh | The structure of hosts is described in NED files (NED is the network description language of OMNeT++.) Operation of the physical layer models, MAC, traffic generator, etc. are in C++ |
Several model parameters are specified in the omnetpp.ini file.
|
| OneFifo | This scenario simulates a single FIFO queue with a specified number of jobs and capacity. |
|
| TandemFifos | This scenario models a series of queues (tandem queues) where jobs move from one queue to the next. |
|
| Closed Queueing Network (SmallCQN) | This scenario simulates a closed queueing network with two main queues, where jobs circulate between them. |
|
| Ring | The Ring scenario simulates a server ring where jobs are processed in a circular fashion. |
|
| Terminal | This scenario models job flows at a flight terminal, where passengers undergo various processing stages (e.g., check-in, security). |
|
| CallCenter | The CallCenter scenario simulates a call center handling incoming customer requests with varying priorities. |
|
| ForkJoin | In this scenario, jobs are split into parallel tasks and rejoined after processing. |
|
| ResourceAllocation | This scenario models a system where two queues share a common resource. |
|
| AllocDealloc | This scenario models dynamic resource allocation where resources are assigned and released based on demand. |
|
| Scenario | Output Description |
| Random Mesh | The model computes summary statistics during the simulation execution to minimize disk space usage and facilitate the results analysis. The selected nodes generate end-to-end delay and hop count statistics (among which: mean, median, minimum and maximum). |
| OneFifo | The simulation outputs detailed job statistics, including average queue length, waiting times, and job service times. These statistics help evaluate the performance of the queue under heavy workloads and provide insights into potential bottlenecks. |
| TandemFifos | The output provides statistics on how jobs flow through the queues, including the waiting times, service times at each stage, and overall system performance. The results highlight the efficiency of job progression through multiple processing stages. |
| Closed Queueing Network (SmallCQN) | The simulation captures job cycle times, queue lengths, and service times statistics. This helps assess system performance and job flow in a closed environment, where jobs continuously cycle between queues. |
| Ring | Output includes detailed statistics on job processing times, queue lengths at each server, and overall system utilization. The ring structure allows for load balancing and job distribution analysis across the network. |
| Terminal | The simulation produces statistics on passenger wait times, processing times, and overall terminal throughput. The output is useful for analyzing bottlenecks in a terminal-like environment. |
| CallCenter | This scenario outputs statistics on call waiting times, call service times, and the effectiveness of different queueing and priority-based dispatching strategies. Results help evaluate system performance under different traffic loads and job prioritization rules. |
| ForkJoin | The output includes task completion, total job processing times, and system throughput metrics. The ForkJoin model is useful for assessing parallel job handling and the efficiency of task coordination. |
| ResourceAllocation | The simulation outputs statistics on resource utilization, job waiting times, and queue lengths. The results provide insight into how effectively shared resources are managed and allocated under varying job loads. |
| AllocDealloc | Output includes statistics on resource usage, job waiting times, and system performance as resources are allocated and deallocated dynamically. This helps assess the impact of resource management on system efficiency. |
C++
The SPECrate version is single-threaded.
OMNeT++ makes use of std::isnan, and as such, support for infinite math is required.
OMNET++ is licensed directly to SPEC by OpenSim Ltd. authors Marcel Marek and András Varga. Releases are available from omnetpp.org and OMNET++ sources are at GitHub. The 710.omnetpp_r benchmark is based on an April 2023 snapshot.
The files simulator/common/yxml.c and yxml.h (available at https://code.blicky.net/yorhel/yxml) use the MIT License, copyrighted Yoran Heling.
The benchmark includes a version of Mersenne Twister (available at https://doc.omnetpp.org/omnetpp/api/mersennetwister_8h_source.html) under the BSD license, copyrighted Makoto Matsumoto and Takuji Nishimura; Richard J. Wagner
These files are generated by the Bison parser (GNU GPL) generator
The above are licensed under the same terms as the rest of the benchmark, not GPL, in accordance with the Bison special exception:
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
Copyright © 2026 Standard Performance Evaluation Corporation (SPEC®)