Appendix: Configuration Options

Configuration Options

This section lists all configuration options that are available in ini files. A similar list can be obtained from any simulation executable by running it with the -h configdetails option.

abstract
= <bool>, default: false
Per-simulation-run setting.
Declares whether this configuration is an abstract one. Abstract configurations serve as a base for other configurations, and are not meant to be run directly.
allow-object-stealing-on-deletion
= <bool>, default: false
Per-simulation-run setting.
Setting it to true disables the “Context component is deleting an object it doesn’t own” error message. This option exists primarily for backward compatibility with pre-6.0 versions that were more permissive during object deletion.
**.bin-recording
= <bool>, default: true
Per-object setting for scalar results.
Whether the bins of the matching histogram object should be recorded, provided that recording of the histogram object itself is enabled (**.<scalar-name>.scalar-recording=true).
Usage: <module-full-path>.<scalar-name>.bin-recording=true/false. To control histogram recording from a @statistic, use <statistic-name>:histogram for <scalar-name>.
Example: **.ping.round­Trip­Time:histogram.bin-recording=false
check-signals
= <bool>, default: true
Per-simulation-run setting.
Controls whether the simulation kernel will validate signals emitted by modules and channels against signal declarations (@signal properties) in NED files. The default setting depends on the build type: true in DEBUG, and false in RELEASE mode.
cmdenv-autoflush
= <bool>, default: false
Per-simulation-run setting.
Call fflush(stdout) after each event banner or status update; affects both express and normal mode. Turning on autoflush may have a performance penalty, but it can be useful with printf-style debugging for tracking down program crashes.
cmdenv-config-name
= <string>
Global setting (applies to all simulation runs).
Specifies the name of the configuration to be run (for a value Foo, section [Config Foo] will be used from the ini file). See also cmdenv-runs-to-execute. The -c command line option overrides this setting.
cmdenv-event-banner-details
= <bool>, default: false
Per-simulation-run setting.
When cmdenv-express-mode=false: print extra information after event banners.
cmdenv-event-banners
= <bool>, default: true
Per-simulation-run setting.
When cmdenv-express-mode=false: turns printing event banners on/off.
cmdenv-express-mode
= <bool>, default: true
Per-simulation-run setting.
Selects normal (debug/trace) or express mode.
cmdenv-extra-stack
= <double>, unit=B, default: 8Ki­B
Global setting (applies to all simulation runs).
Specifies the extra amount of stack that is reserved for each activity() simple module when the simulation is run under Cmdenv.
cmdenv-fake-gui
= <bool>, default: false
Per-simulation-run setting.
Causes Cmdenv to lie to simulations that is a GUI (isGui()=true), and to periodically invoke refreshDisplay() during simulation execution.
cmdenv-fake-gui-after-event-probability
= <double>, default: 1
Per-simulation-run setting.
When cmdenv-fake-gui=true: The probability with which refresh­Display() is called after each event.
cmdenv-fake-gui-before-event-probability
= <double>, default: 1
Per-simulation-run setting.
When cmdenv-fake-gui=true: The probability with which refresh­Display() is called before each event.
cmdenv-fake-gui-on-hold-numsteps
= <custom>, default: 3
Per-simulation-run setting.
When cmdenv-fake-gui=true: The number of times refresh­Display() is called during a “hold” period (animation during which simulation time does not advance), provided a trial with cmdenv-fake-gui-on-hold-probability yielded success. This an expression which will be evaluated each time, so it can be random. Zero is also a valid value.
cmdenv-fake-gui-on-hold-probability
= <double>, default: 0.5
Per-simulation-run setting.
When cmdenv-fake-gui=true: The probability with which refresh­Display() is called (possibly multiple times, see cmdenv-fake-gui-on-hold-numsteps) during a “hold” period (animation during which simulation time does not advance).
cmdenv-fake-gui-on-simtime-numsteps
= <custom>, default: 3
Per-simulation-run setting.
When cmdenv-fake-gui=true: The number of times refresh­Display() is called when simulation time advances from one simulation event to the next, provided a trial with cmdenv-fake-gui-on-simtime-probability yielded success. This an expression which will be evaluated each time, so it can be random. Zero is also a valid value.
cmdenv-fake-gui-on-simtime-probability
= <double>, default: 0.1
Per-simulation-run setting.
When cmdenv-fake-gui=true: The probability with which refresh­Display() is called (possibly multiple times, see cmdenv-fake-gui-on-simtime-numsteps) when simulation time advances from one simulation event to the next.
cmdenv-fake-gui-seed
= <int>, default: 1
Per-simulation-run setting.
When cmdenv-fake-gui=true: The seed for the RNG governing the operation of the fake GUI component. This is entirely independent of the RNGs used by the model.
cmdenv-interactive
= <bool>, default: false
Per-simulation-run setting.
Defines what Cmdenv should do when the model contains unassigned parameters. In interactive mode, it asks the user. In non-interactive mode (which is more suitable for batch execution), Cmdenv stops with an error.
cmdenv-log-cleanup
= <bool>, default: false
Per-simulation-run setting.
Specifies whether to enable logging during network cleanup.
cmdenv-log-finalization
= <bool>
Per-simulation-run setting.
Specifies whether to enable logging during network finalization. The default depends on whether the simulation is run in express mode or not (see cmdenv-express-mode).
cmdenv-log-initialization
= <bool>
Per-simulation-run setting.
Specifies whether to enable logging during network initialization. The default depends on whether the simulation is run in express mode or not (see cmdenv-express-mode).
**.cmdenv-log-level
= <string>, default: TRACE
Per-object setting for modules.
Specifies the per-component level of detail recorded by log statements, output below the specified level is omitted. Available values are (case insensitive): off, fatal, error, warn, info, detail, debug or trace. Note that the level of detail is also controlled by the globally specified runtime log level and the COMPILETIME_LOGLEVEL macro that is used to completely remove log statements from the executable.
cmdenv-log-prefix
= <string>, default: [%l]
Per-simulation-run setting.
Specifies the format string that determines the prefix of each log line. The format string may contain format directives in the syntax %x (a % followed by a single format character). For example %l stands for log level, and %J for source component. See the manual for the list of available format characters.
cmdenv-log-simulation
= <bool>
Per-simulation-run setting.
Specifies whether to enable logging during the simulation, i.e. event processing. The default depends on whether the simulation is run in express mode or not (see cmdenv-express-mode).
cmdenv-output-file
= <filename>, default: ${resultdir}/${configname}-${iterationvarsf}#${repetition}.out
Per-simulation-run setting.
When cmdenv-record-output=true: file name to redirect standard output to. See also fname-append-host.
cmdenv-performance-display
= <bool>, default: true
Per-simulation-run setting.
When cmdenv-express-mode=true: print detailed performance information. Turning it on results in a 3-line entry printed on each update, containing ev/sec, simsec/sec, ev/simsec, number of messages created/still present/currently scheduled in FES.
cmdenv-progress-updates
= <bool>, default: true
Per-simulation-run setting.
When cmdenv-express-mode=true: print a periodic status update on the progress of the simulation.
cmdenv-redirect-output
= <bool>, default: false
Per-simulation-run setting.
Causes Cmdenv to redirect standard output of simulation runs to a file or separate files per run. This option can be useful with running simulation campaigns (e.g. using opp_runall), and also with parallel simulation. See also: cmdenv-output-file, fname-append-host.
cmdenv-runs-to-execute
= <string>
Global setting (applies to all simulation runs).
Specifies which runs to execute from the selected configuration (see cmdenv-config-name option). It accepts a filter expression of iteration variables such as , or a comma-separated list of run numbers or run number ranges, e.g. 1,3..4,7..9. If the value is missing, Cmdenv executes all runs in the selected configuration. The -r command line option overrides this setting.
cmdenv-status-frequency
= <double>, unit=s, default: 2s
Per-simulation-run setting.
When cmdenv-express-mode=true: print status update every n seconds.
cmdenv-stop-batch-on-error
= <bool>, default: true
Per-simulation-run setting.
Decides whether Cmdenv should skip the rest of the runs when an error occurs during the execution of one run.
config-recording
= <custom>, default: all
Per-simulation-run setting.
Selects the set of config options to save into result files. This option can help reduce the size of result files, which is especially useful in the case of large simulation campaigns. Possible values: all, none, config, params, essentials, globalconfig
configuration-class
= <string>
Global setting (applies to all simulation runs).
Part of the Envir plugin mechanism: selects the class from which all configuration information will be obtained. This option lets you replace omnetpp.ini with some other implementation, e.g. database input. The simulation program still has to bootstrap from an omnetpp.ini (which contains the configuration-class setting). The class should implement the cConfiguration­Ex interface.
constraint
= <string>
Per-simulation-run setting.
For scenarios. Contains an expression that iteration variables (${} syntax) must satisfy for that simulation to run. Example: $i < $j+1.
cpu-time-limit
= <double>, unit=s
Per-simulation-run setting.
Stops the simulation when CPU usage has reached the given limit. The default is no limit. Note: To reduce per-event overhead, this time limit is only checked every N events (by default, N=1024).
debug-on-errors
= <bool>, default: false
Per-simulation-run setting.
When set to true, runtime errors will cause the simulation program to break into the C++ debugger (if the simulation is running under one, or just-in-time debugging is activated). Once in the debugger, you can view the stack trace or examine variables.
debug-statistics-recording
= <bool>, default: false
Per-simulation-run setting.
Turns on the printing of debugging information related to statistics recording (@statistic properties)
debugger-attach-command
= <string>
Global setting (applies to all simulation runs).
The command line to launch the debugger. It must contain exactly one percent sign, as %u, which will be replaced by the PID of this process. The command must not block (i.e. it should end in & on Unix-like systems). It will be executed by the default system shell (on Windows, usually cmd.exe). Default on this platform: . This default can be overridden with the OMNETPP_DEBUGGER_COMMAND environment variable.
debugger-attach-on-error
= <bool>, default: false
Global setting (applies to all simulation runs).
When set to true, runtime errors and crashes will trigger an external debugger to be launched (if not already present), allowing you to perform just-in-time debugging on the simulation process. The debugger command is configurable. Note that debugging (i.e. attaching to) a non-child process needs to be explicitly enabled on some systems, e.g. Ubuntu.
debugger-attach-on-startup
= <bool>, default: false
Global setting (applies to all simulation runs).
When set to true, the simulation program will launch an external debugger attached to it (if not already present), allowing you to set breakpoints before proceeding. The debugger command is configurable. Note that debugging (i.e. attaching to) a non-child process needs to be explicitly enabled on some systems, e.g. Ubuntu.
debugger-attach-wait-time
= <double>, unit=s, default: 20s
Global setting (applies to all simulation runs).
An interval to wait after launching the external debugger, to give the debugger time to start up and attach to the simulation process.
description
= <string>
Per-simulation-run setting.
Descriptive name for the given simulation configuration. Descriptions get displayed in the run selection dialog.
**.display-name
= <string>
Per-object setting for modules.
Specifies a display name for the module, which is shown e.g. in Qtenv’s graphical module view.
**.display-string
= <string>
Per-object setting for modules and channels.
Additional display string for the module/channel; it will be merged into the display string given via @display properties, and override its content.
eventlog-file
= <filename>, default: ${resultdir}/${configname}-${iterationvarsf}#${repetition}.elog
Per-simulation-run setting.
Name of the eventlog file to generate.
eventlog-index-frequency
= <double>, unit=B, default: 1 Mi­B
Per-simulation-run setting.
The eventlog file contains incremental snapshots called index. An index is much smaller than a full snapshot, but it only contains the differences since the last index.
eventlog-max-size
= <double>, unit=B, default: 10 Gi­B
Per-simulation-run setting.
Specify the maximum size of the eventlog file in bytes. The eventlog file is automatically truncated when this limit is reached.
eventlog-message-detail-pattern
= <custom>
Per-simulation-run setting.
A list of patterns separated by ’|’ character which will be used to write message detail information into the eventlog for each message sent during the simulation. The message detail will be presented in the sequence chart tool. Each pattern starts with an object pattern optionally followed by ’:’ character and a comma separated list of field patterns. In both patterns and/or/not/* and various field match expressions can be used. The object pattern matches to class name, the field pattern matches to field name by default.
EVENTLOG-MESSAGE-DETAIL-PATTERN := ( DETAIL-PATTERN ’|’ )* DETAIL_PATTERN
DETAIL-PATTERN := OBJECT-PATTERN [ ’:’ FIELD-PATTERNS ]
OBJECT-PATTERN := MATCH-EXPRESSION
FIELD-PATTERNS := ( FIELD-PATTERN ’,’ )* FIELD_PATTERN
FIELD-PATTERN := MATCH-EXPRESSION
Examples:
*: captures all fields of all messages
*Frame:*Address,*Id: captures all fields named somethingAddress and somethingId from messages of any class named somethingFrame
My­Message:declared­On=~My­Message: captures instances of MyMessage recording the fields declared on the MyMessage class
*:(not declared­On=~cMessage and not declared­On=~cNamed­Object and not declared­On=~cObject): records user-defined fields from all messages
eventlog-min-truncated-size
= <double>, unit=B, default: 1 Gi­B
Per-simulation-run setting.
Specify the minimum size of the eventlog file in bytes after the file is truncated. Truncation means older events are discarded while newer ones are kept.
eventlog-options
= <custom>
Per-simulation-run setting.
Allows for reducing the size of the eventlog file by recording only specific types of content. Specify a comma-separated subset of the following keywords: text, message, module, methodcall, displaystring and custom. By default, all categories are enabled.
eventlog-recording-intervals
= <custom>
Per-simulation-run setting.
Simulation time interval(s) when events should be recorded. Syntax: [<from>]..[<to>],... That is, both start and end of an interval are optional, and intervals are separated by comma. Example: ..10.2, 22.2..100, 233.3..
eventlog-snapshot-frequency
= <double>, unit=B, default: 100 Mi­B
Per-simulation-run setting.
The eventlog file contains periodically recorded snapshots. Each one describes the complete simulation state at a specific event. Snapshots help various tools to handle large eventlog files more efficiently. Specifying greater value means less help, while smaller value means bigger eventlog files.
eventlogmanager-class
= <string>, default: omnetpp::envir::Eventlog­File­Manager
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the eventlog manager class to be used to record data. The class has to implement the cIEventlog­Manager interface.
experiment-label
= <string>, default: ${configname}
Per-simulation-run setting.
Identifies the simulation experiment (which consists of several, potentially repeated measurements). This string gets recorded into result files, and may be referred to during result analysis.
extends
= <string>
Per-simulation-run setting.
Name of the configuration this section is based on. Entries from that section will be inherited and can be overridden. In other words, configuration lookups will fall back to the base section.
fingerprint
= <string>
Per-simulation-run setting.
The expected fingerprints of the simulation. If you need multiple fingerprints, separate them with commas. When provided, the fingerprints will be calculated from the specified properties of simulation events, messages, and statistics during execution, and checked against the provided values. Fingerprints are suitable for crude regression tests. As fingerprints occasionally differ across platforms, more than one value can be specified for a single fingerprint, separated by spaces, and a match with any of them will be accepted. To obtain a fingerprint, enter a dummy value (such as 0000), and run the simulation.
fingerprint-events
= <string>, default: *
Per-simulation-run setting.
Configures the fingerprint calculator to consider only certain events. The value is a pattern that will be matched against the event name by default. It may also be an expression containing pattern matching characters, field access, and logical operators. The default setting is ’*’ which includes all events in the calculated fingerprint. If you configured multiple fingerprints, separate filters with commas.
fingerprint-ingredients
= <string>, default: tplx
Per-simulation-run setting.
Specifies the list of ingredients to be taken into account for fingerprint computation. Each character corresponds to one ingredient: ’e’ event number, ’t’ simulation time, ’n’ message (event) full name, ’c’ message (event) class name, ’k’ message kind, ’l’ message bit length, ’o’ message control info class name, ’d’ message data, ’i’ module id, ’m’ module full name, ’p’ module full path, ’a’ module class name, ’r’ random numbers drawn, ’s’ scalar results, ’z’ statistic results, ’v’ vector results, ’x’ extra data provided by modules. Note: ingredients specified in an expected fingerprint (characters after the ’/’ in the fingerprint value) take precedence over this setting. If you configured multiple fingerprints, separate ingredients with commas.
fingerprint-modules
= <string>, default: *
Per-simulation-run setting.
Configures the fingerprint calculator to consider only certain modules. The value is a pattern that will be matched against the module full path by default. It may also be an expression containing pattern matching characters, field access, and logical operators. The default setting is ’*’ which includes all events in all modules in the calculated fingerprint. If you configured multiple fingerprints, separate filters with commas.
fingerprint-results
= <string>, default: *
Per-simulation-run setting.
Configures the fingerprint calculator to consider only certain results. The value is a pattern that will be matched against the result full path by default. It may also be an expression containing pattern matching characters, field access, and logical operators. The default setting is ’*’ which includes all results in all modules in the calculated fingerprint. If you configured multiple fingerprints, separate filters with commas.
fingerprintcalculator-class
= <string>, default: omnetpp::cSingle­Fingerprint­Calculator
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the fingerprint calculator class to be used to calculate the simulation fingerprint. The class has to implement the cFingerprint­Calculator interface.
fname-append-host
= <bool>
Global setting (applies to all simulation runs).
Turning it on will cause the host name and process Id to be appended to the names of output files (e.g. omnetpp.vec, omnetpp.sca). This is especially useful with distributed simulation. The default value is true if parallel simulation is enabled, false otherwise.
futureeventset-class
= <string>, default: omnetpp::cEvent­Heap
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the class for storing the future events in the simulation. The class has to implement the cFuture­Event­Set interface.
image-path
= <path>, default: ./images
Global setting (applies to all simulation runs).
A semicolon-separated list of directories that contain module icons and other resources. This list will be concatenated with the contents of the OMNETPP_IMAGE_PATH environment variable or with a compile-time, hardcoded image path if the environment variable is empty.
iteration-nesting-order
= <string>
Per-simulation-run setting.
Specifies the loop nesting order for iteration variables (${} syntax). The value is a comma-separated list of iteration variables; the list may also contain at most one asterisk. Variables that are not explicitly listed will be inserted at the position of the asterisk, or appended to the list if there is no asterisk. The first variable will become the outermost loop, and the last one the innermost loop. Example: repetition,num­Hosts,*,ia­Time.
load-libs
= <filenames>
Global setting (applies to all simulation runs).
A space-separated list of dynamic libraries to be loaded on startup. The libraries should be given without the .dll or .so suffix – that will be automatically appended.
max-module-nesting
= <int>, default: 50
Per-simulation-run setting.
The maximum allowed depth of submodule nesting. This is used to catch accidental infinite recursions in NED.
measurement-label
= <string>, default: ${iterationvars}
Per-simulation-run setting.
Identifies the measurement within the experiment. This string gets recorded into result files, and may be referred to during result analysis.
**.module-eventlog-recording
= <bool>, default: true
Per-object setting for simple modules.
Enables recording events on a per module basis. This is meaningful for simple modules only. Usage: <module-full-path>.module-eventlog-recording=true/false. Examples: **.router[10..20].**.module-eventlog-recording = true; **.module-eventlog-recording = false
ned-package-exclusions
= <custom>
Global setting (applies to all simulation runs).
A semicolon-separated list of NED packages to be excluded when loading NED files. Sub-packages of excluded ones are also excluded. Additional items may be specified via the -x command-line option and the OMNETPP_NED_PACKAGE_EXCLUSIONS environment variable.
ned-path
= <path>
Global setting (applies to all simulation runs).
A semicolon-separated list of directories. The directories will be regarded as roots of the NED package hierarchy, and all NED files will be loaded from their subdirectory trees. This option is normally left empty, as the OMNeT++ IDE sets the NED path automatically, and for simulations started outside the IDE it is more convenient to specify it via command-line option (-n) or via environment variable (OMNETPP_NED_PATH, NEDPATH).
network
= <string>
Per-simulation-run setting.
The name of the network to be simulated. The package name can be omitted if the ini file is in the same directory as the NED file that contains the network.
num-rngs
= <int>, default: 1
Per-simulation-run setting.
The number of random number generators.
output-scalar-db-commit-freq
= <int>, default: 100000
Global setting (applies to all simulation runs).
Used with SqliteOutputScalarManager: COMMIT every n INSERTs.
output-scalar-file
= <filename>, default: ${resultdir}/${configname}-${iterationvarsf}#${repetition}.sca
Per-simulation-run setting.
Name for the output scalar file.
output-scalar-file-append
= <bool>, default: false
Per-simulation-run setting.
What to do when the output scalar file already exists: append to it (OMNeT++ 3.x behavior), or delete it and begin a new file (default).
output-scalar-precision
= <int>, default: 17
Per-simulation-run setting.
The number of significant digits for recording data into the output scalar file. The maximum value is ~15 (IEEE double precision). This has no effect on SQLite recording, as it stores values as 8-byte IEEE floating point numbers.
output-vector-db-indexing
= <custom>, default: skip
Global setting (applies to all simulation runs).
Whether and when to add an index to the ’vectordata’ table in SQLite output vector files. Possible values: skip, ahead, after
output-vector-file
= <filename>, default: ${resultdir}/${configname}-${iterationvarsf}#${repetition}.vec
Per-simulation-run setting.
Name for the output vector file.
output-vector-file-append
= <bool>, default: false
Per-simulation-run setting.
What to do when the output vector file already exists: append to it, or delete it and begin a new file (default). Note: cIndexed­File­Output­Vector­Manager currently does not support appending.
output-vector-precision
= <int>, default: 17
Per-simulation-run setting.
The number of significant digits for recording data into the output vector file. The maximum value is ~15 (IEEE double precision). This setting has no effect on SQLite recording (it stores values as 8-byte IEEE floating point numbers), and for the “time” column which is represented as fixed-point numbers and always get recorded precisely.
output-vectors-memory-limit
= <double>, unit=B, default: 16Mi­B
Per-simulation-run setting.
Total memory that can be used for buffering output vectors. Larger values produce less fragmented vector files (i.e. cause vector data to be grouped into larger chunks), and therefore allow more efficient processing later. There is also a per-vector limit, see **.vector-buffer.
outputscalarmanager-class
= <string>, default: omnetpp::envir::Omnetpp­Output­Scalar­Manager
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the output scalar manager class to be used to record data passed to recordScalar(). The class has to implement the cIOutput­Scalar­Manager interface.
outputvectormanager-class
= <string>, default: omnetpp::envir::Omnetpp­Output­Vector­Manager
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the output vector manager class to be used to record data from output vectors. The class has to implement the cIOutput­Vector­Manager interface.
parallel-simulation
= <bool>, default: false
Global setting (applies to all simulation runs).
Enables parallel distributed simulation.
**.param-record-as-scalar
= <bool>, default: false
Per-object setting for module/channel parameters.
Applicable to module parameters: specifies whether the module parameter should be recorded into the output scalar file. Set it for parameters whose value you will need for result analysis.
**.param-recording
= <bool>, default: true
Per-object setting for module/channel parameters.
Whether the matching module (and channel) parameters should be recorded.
Usage: <module-full-path>.<parameter-name>.param-recording=true/false.
Example: **.app.pk­Len.param-recording=true
parameter-mutability-check
= <bool>, default: true
Per-simulation-run setting.
Setting to false will disable errors raised when trying to change the values of module/channel parameters not marked as @mutable. This is primarily a compatibility setting intended to facilitate running simulation models that were not yet annotated with @mutable.
parsim-communications-class
= <string>, default: omnetpp::cFile­Communications
Global setting (applies to all simulation runs).
If parallel-simulation=true, it selects the class that implements communication between partitions. The class must implement the cParsim­Communications interface.
parsim-debug
= <bool>, default: true
Global setting (applies to all simulation runs).
With parallel-simulation=true: turns on printing of log messages from the parallel simulation code.
parsim-filecommunications-prefix
= <string>, default: comm/
Global setting (applies to all simulation runs).
When cFile­Communications is selected as parsim communications class: specifies the prefix (directory+potential filename prefix) for creating the files for cross-partition messages.
parsim-filecommunications-preserve-read
= <bool>, default: false
Global setting (applies to all simulation runs).
When cFile­Communications is selected as parsim communications class: specifies that consumed files should be moved into another directory instead of being deleted.
parsim-filecommunications-read-prefix
= <string>, default: comm/read/
Global setting (applies to all simulation runs).
When cFile­Communications is selected as parsim communications class: specifies the prefix (directory) where files will be moved after having been consumed.
parsim-idealsimulationprotocol-tablesize
= <int>, default: 100000
Global setting (applies to all simulation runs).
When cIdeal­Simulation­Protocol is selected as parsim synchronization class: specifies the memory buffer size for reading the ISP event trace file.
parsim-mpicommunications-mpibuffer
= <int>
Global setting (applies to all simulation runs).
When cMPICommunications is selected as parsim communications class: specifies the size of the MPI communications buffer. The default is to calculate a buffer size based on the number of partitions.
parsim-namedpipecommunications-prefix
= <string>, default: comm/
Global setting (applies to all simulation runs).
When cNamed­Pipe­Communications is selected as parsim communications class: selects the prefix (directory+potential filename prefix) where name pipes are created in the file system.
parsim-nullmessageprotocol-laziness
= <double>, default: 0.5
Global setting (applies to all simulation runs).
When cNull­Message­Protocol is selected as parsim synchronization class: specifies the laziness of sending null messages. Values in the range [0,1) are accepted. Laziness=0 causes null messages to be sent out immediately as a new EOT is learned, which may result in excessive null message traffic.
parsim-nullmessageprotocol-lookahead-class
= <string>, default: cLink­Delay­Lookahead
Global setting (applies to all simulation runs).
When cNull­Message­Protocol is selected as parsim synchronization class: specifies the C++ class that calculates lookahead. The class should subclass from cNMPLookahead.
parsim-num-partitions
= <int>
Global setting (applies to all simulation runs).
If parallel-simulation=true, it tells the number of parallel processes to use. This value must be in agreement with the number of simulator instances launched, e.g. with the -n or -np command-line option specified to the mpirun program.
parsim-synchronization-class
= <string>, default: omnetpp::cNull­Message­Protocol
Global setting (applies to all simulation runs).
If parallel-simulation=true, it selects the parallel simulation algorithm. The class must implement the cParsim­Synchronizer interface.
**.partition-id
= <string>
Per-object setting for modules.
With parallel simulation: in which partition the module should be instantiated. Specify numeric partition ID, or a comma-separated list of partition IDs for compound modules that span across multiple partitions. Ranges (5..9) and * (=all) are accepted too.
print-instantiated-ned-types
= <bool>, default: false
Per-simulation-run setting.
When set to true, the simulation will print the names of all instantiated NED types at the end of the simulation. This is useful for coverage tests.
print-undisposed
= <bool>, default: true
Per-simulation-run setting.
Whether to report objects left (that is, not deallocated by simple module destructors) after network cleanup.
print-unused-parameters
= <bool>, default: false
Per-simulation-run setting.
When set to true, the simulation will print the names of all parameters that have not been accessed during simulation, i.e. did not have any effect, pointing to possible deficiencies in the model.
qtenv-default-config
= <string>
Global setting (applies to all simulation runs).
Specifies which config Qtenv should set up automatically on startup. The default is to ask the user.
qtenv-default-run
= <string>
Global setting (applies to all simulation runs).
Specifies which run (of the default config, see qtenv-default-config) Qtenv should set up automatically on startup. A run filter is also accepted. The default is to ask the user.
qtenv-extra-stack
= <double>, unit=B, default: 80Ki­B
Global setting (applies to all simulation runs).
Specifies the extra amount of stack that is reserved for each activity() simple module when the simulation is run under Qtenv.
qtenv-identicon-seed
= <string>
Per-simulation-run setting.
Overrides the default (computed) identicon seed for the current run. The identicon is a small image that is shown in the upper right corner of the Qtenv main window, and its purpose is help the user visually identify the window if there are multiple Qtenv simulations running at the same time. The image is generated from a seed. By default, the seed is computed from various properties of the simulation (config name, run number, configuration contents, etc) that ensures that different simulations result in different images, but multiple launches of the same simulation result in the same identicon. This configuration option allows the user to override this default behavior and force a specific seed.
real-time-limit
= <double>, unit=s
Per-simulation-run setting.
Stops the simulation after the specified amount of time has elapsed. The default is no limit. Note: To reduce per-event overhead, this time limit is only checked every N events (by default, N=1024).
realtimescheduler-scaling
= <double>
Global setting (applies to all simulation runs).
When cRealTimeScheduler is selected as scheduler class: ratio of simulation time to real time. For example, realtimescheduler-scaling=2 will cause simulation time to progress twice as fast as runtime.
record-eventlog
= <bool>, default: false
Per-simulation-run setting.
Enables recording an eventlog file, which can be later visualized on a sequence chart. See eventlog-file option too.
record-scalar-results
= <bool>, default: true
Per-simulation-run setting.
Enables writing an output scalar (.sca) file. See the output-scalar-file option too.
record-vector-results
= <bool>, default: true
Per-simulation-run setting.
Enables writing an output vector (.vec) file. See the output-vector-file option too.
repeat
= <int>, default: 1
Per-simulation-run setting.
For scenarios. Specifies how many replications should be done with the same parameters (iteration variables). This is typically used to perform multiple runs with different random number seeds. The loop variable is available as ${repetition}. See also: seed-set key.
replication-label
= <string>, default: #${repetition}
Per-simulation-run setting.
Identifies one replication of a measurement (see repeat and measurement-label options as well). This string gets recorded into result files, and may be referred to during result analysis.
result-dir
= <string>, default: results
Per-simulation-run setting.
Base value for the ${resultdir} variable, which is used as the default directory for result files (output vector file, output scalar file, eventlog file, etc.). See also the resultdir-subdivision config option.
**.result-recording-modes
= <string>, default: default
Per-object setting for statistics (@statistic).
Defines how to calculate results from the matching @statistic.
Usage: <module-full-path>.<statistic-name>.result-recording-modes=<modes>. Special values: default, all: they select the modes listed in the record key of @statistic; all selects all of them, default selects the non-optional ones (i.e. excludes the ones that end in a question mark). Example values: vector, count, last, sum, mean, min, max, timeavg, stats, histogram. More than one values are accepted, separated by commas. Expressions are allowed. Items prefixed with - get removed from the list. Example: **.queue­Length.result-recording-modes=default,-vector,+timeavg
resultdir-subdivision
= <bool>, default: false
Per-simulation-run setting.
Makes the results directory hierarchical by appending ${iterationvarsd} to the value of the result-dir config option. This is useful if a parameter study produces a large number of runs (>10000), as many file managers and other tools (including the OMNeT++ IDE) struggle with directories containing that many files. An alternative to using this option is to include iteration variables directly in the value of the result-dir option.
**.rng-%
= <int>
Per-object setting for modules and channels.
Maps a module-local RNG to one of the global RNGs. Example: **.gen.rng-1=3 maps the local RNG 1 of modules matching **.gen to the global RNG 3. The value may be an expression, with the index and ancestor­Index() operators being potentially very useful. The default is one-to-one mapping, i.e. RNG k of all modules refer to the global RNG k ().
Usage: <module-full-path>.rng-<local-index>=<global-index>. Examples: **.mac.rng-0=1; **.source[*].rng-0=index
rng-class
= <string>, default: omnetpp::cMersenne­Twister
Per-simulation-run setting.
The random number generator class to be used. It can be cMersenne­Twister, cLCG32, cAkaroa­RNG, or you can use your own RNG class (it must be subclassed from cRNG).
rngmanager-class
= <string>, default: omnetpp::cRng­Manager
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the RNG manager class to be used for providing RNGs to modules and channels. The class has to implement the cIRng­Manager interface.
runnumber-width
= <int>, default: 0
Per-simulation-run setting.
Setting a nonzero value will cause the $runnumber variable to get padded with leading zeroes to the given length.
**.scalar-recording
= <bool>, default: true
Per-object setting for scalar results.
Whether the matching output scalars and statistic objects should be recorded.
Usage: <module-full-path>.<scalar-name>.scalar-recording=true/false. To enable/disable individual recording modes for a @statistic (those added via the record=... key of @statistic or the **.result-recording-modes=... config option), use <statistic-name>:<mode> for <scalar-name>, and make sure the @statistic as a whole is not disabled with **.<statistic-name>.statistic-recording=false.
Example: **.ping.round­Trip­Time:stddev.scalar-recording=false
scheduler-class
= <string>, default: omnetpp::cSequential­Scheduler
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the scheduler class. This plugin interface allows for implementing real-time, hardware-in-the-loop, distributed and distributed parallel simulation. The class has to implement the cScheduler interface.
sectionbasedconfig-configreader-class
= <string>
Global setting (applies to all simulation runs).
When configuration-class=Section­Based­Configuration: selects the configuration reader C++ class, which must subclass from cConfiguration­Reader.
seed-%-lcg32
= <int>
Per-simulation-run setting.
When cLCG32 is selected as random number generator: seed for the kth RNG. (Substitute k for ’%’ in the key.)
seed-%-mt
= <int>
Per-simulation-run setting.
When Mersenne Twister is selected as random number generator (default): seed for RNG number k. (Substitute k for ’%’ in the key.)
seed-%-mt-p%
= <int>
Per-simulation-run setting.
With parallel simulation: When Mersenne Twister is selected as random number generator (default): seed for RNG number k in partition number p. (Substitute k for the first ’%’ in the key, and p for the second.)
seed-set
= <int>, default: ${runnumber}
Per-simulation-run setting.
Selects the kth set of automatic random number seeds for the simulation. Meaningful values include ${repetition} which is the repeat loop counter (see repeat option), and ${runnumber}.
sim-time-limit
= <double>, unit=s
Per-simulation-run setting.
Stops the simulation when simulation time reaches the given limit. The default is no limit.
simtime-resolution
= <custom>, default: ps
Global setting (applies to all simulation runs).
Sets the resolution for the 64-bit fixed-point simulation time representation. Accepted values are: second-or-smaller time units (s, ms, us, ns, ps, fs or as), power-of-ten multiples of such units (e.g. 100ms), and base-10 scale exponents in the -18..0 range. The maximum representable simulation time depends on the resolution. The default is picosecond resolution, which offers a range of ~110 days.
simtime-scale
= <int>, default: -12
Global setting (applies to all simulation runs).
DEPRECATED in favor of simtime-resolution. Sets the scale exponent, and thus the resolution of time for the 64-bit fixed-point simulation time representation. Accepted values are -18..0; for example, -6 selects microsecond resolution. -12 means picosecond resolution, with a maximum simtime of ~110 days.
snapshot-file
= <filename>, default: ${resultdir}/${configname}-${iterationvarsf}#${repetition}.sna
Per-simulation-run setting.
Name of the snapshot file.
snapshotmanager-class
= <string>, default: omnetpp::envir::File­Snapshot­Manager
Per-simulation-run setting.
Part of the Envir plugin mechanism: selects the class to handle streams to which snapshot() writes its output. The class has to implement the cISnapshot­Manager interface.
**.statistic-recording
= <bool>, default: true
Per-object setting for statistics (@statistic).
Whether the matching @statistic should be recorded. This option lets one completely disable all recording from a @statistic. Disabling a @statistic this way is more efficient than specifying **.scalar-recording=false and **.vector-recording=false together.
Usage: <module-full-path>.<statistic-name>.statistic-recording=true/false.
Example: **.ping.round­Trip­Time.statistic-recording=false
total-stack
= <double>, unit=B
Global setting (applies to all simulation runs).
Specifies the maximum memory for activity() simple module stacks. You need to increase this value if you get a “Cannot allocate coroutine stack” error.
**.typename
= <string>
Per-object setting for modules and channels.
Specifies type for submodules and channels declared with ’like <>’.
unused-entry-check
= <string>, default: warning
Per-simulation-run setting.
Specifies what to do with configuration entries that have had no effect in the run, i.e. that no parameter or other setting has been read from. Such entries are often mistakes: typos, renamed or removed parameters or submodules, a module type that lacks the parameter, or an entry hidden by an earlier one or by a value fixed in NED. Values: off, warning, error. The check covers parameter assignments, typename, display-string, display-name and rng-N entries, not result recording options and other per-object options. An entry whose key also occurs earlier in the configuration (i.e. it is overridden) is not reported. The check is skipped in parallel simulation. See also unused-entry-check-time.
unused-entry-check-time
= <string>, default: end
Per-simulation-run setting.
Specifies when to check for configuration entries that have had no effect (see unused-entry-check). Values: initialization: after network initialization, i.e. before the simulation starts; end: after finish() has been called on all modules. Checking after initialization reports problems early, but it also reports entries that are meant for modules created later during the simulation.
user-interface
= <string>
Global setting (applies to all simulation runs).
Selects the user interface to be started. Known good values are Cmdenv and Qtenv. This option is normally left empty, as it is more convenient to specify the user interface via a command-line option or the IDE’s Run and Debug dialogs. New user interfaces can be defined by subclassing cRunnable­Envir.
**.vector-buffer
= <double>, unit=B, default: 1Mi­B
Per-object setting for vector results.
For output vectors: the maximum per-vector buffer space used for storing values before writing them out as a block into the output vector file. There is also a total limit, see output-vectors-memory-limit.
Usage: <module-full-path>.<vector-name>.vector-buffer=<amount>.
**.vector-record-empty
= <bool>, default: true
Per-object setting for vector results.
Whether output vectors that have no data recorded into them should appear in the result file. Turning off this option will delay writing the vector declaration into the result file until there is data recorded into the vector. Usage: <module-full-path>.<vector-name>.vector-record-empty=true/false.
Example: **.ping.round­Trip­Time:vector.vector-record-empty=false
**.vector-record-eventnumbers
= <bool>, default: true
Per-object setting for vector results.
Whether to record event numbers for an output vector. (Values and timestamps are always recorded.) Event numbers are needed by the Sequence Chart Tool, for example.
Usage: <module-full-path>.<vector-name>.vector-record-eventnumbers=true/false.
Example: **.ping.round­Trip­Time:vector.vector-record-eventnumbers=false
**.vector-recording
= <bool>, default: true
Per-object setting for vector results.
Whether data written into an output vector should be recorded.
Usage: <module-full-path>.<vector-name>.vector-recording=true/false. To control vector recording from a @statistic, use <statistic-name>:vector for <vector-name>. Example: **.ping.round­Trip­Time:vector.vector-recording=false
**.vector-recording-intervals
= <custom>
Per-object setting for vector results.
Allows one to restrict recording of an output vector to one or more simulation time intervals. Usage: <module-full-path>.<vector-name>.vector-recording-intervals=<intervals>. The syntax for <intervals> is: [<from>]..[<to>],... That is, both start and end of an interval are optional, and intervals are separated by comma.
Example: **.round­Trip­Time:vector.vector-recording-intervals=..100, 200..400, 900..
warmup-period
= <double>, unit=s
Per-simulation-run setting.
Length of the initial warm-up period. When set, results belonging to the first x seconds of the simulation will not be recorded into output vectors, and will not be counted into output scalars (see option **.result-recording-modes). This option is useful for steady-state simulations. The default is 0s (no warmup period). Note that models that compute and record scalar results manually (via record­Scalar()) will not automatically obey this setting.
warnings
= <bool>, default: true
Per-simulation-run setting.
Enables warnings.

Predefined Variables

Predefined variables that can be used in config values:

${runid}
:
A reasonably globally unique identifier for the run, produced by concatenating the configuration name, run number, date/time, etc.
${inifile}
:
Name of the (primary) inifile
${configname}
:
Name of the active configuration
${runnumber}
:
Sequence number of the current run within all runs in the active configuration
${network}
:
Value of the network configuration option
${experiment}
:
Value of the experiment-label configuration option
${measurement}
:
Value of the measurement-label configuration option
${replication}
:
Value of the replication-label configuration option
${processid}
:
PID of the simulation process
${datetime}
:
Date and time the simulation run was started
${datetimef}
:
Like ${datetime}, but sanitized for use as part of a file name
${resultdir}
:
Value of the result-dir configuration option
${repetition}
:
The iteration number in 0..N-1, where N is the value of the repeat configuration option
${seedset}
:
Value of the seed-set configuration option
${iterationvars}
:
Concatenation of all user-defined iteration variables in name=value form
${iterationvarsf}
:
Like ${iterationvars}, but sanitized for use as part of a file name
${iterationvarsd}
:
Like ${iterationvars}, but for use as hierarchical folder name (it contains slashes where ${iterationvarsf} has commas)