OMNeT++ Changelog

What's new in OMNeT++ 6.0.3

Feb 24, 2024
  • Documentation:
  • Updated install instructions for macOS to support installing on aarch64 based computers using Homebrew.
  • IDE:
  • Updated to Eclipse 4.30, CDT 11.4, Pydev 11.0
  • IDE is now fully supported on macOS/aarch64
  • Model installation dialogs: If the IDE was installed using opp_env, tell the user to install the model with opp_env, too.

New in OMNeT++ 6.0.1 (Sep 1, 2022)

  • Simulation kernel:
  • Fix: Proper namespace resolution for C++ types in @signal declarations.
  • Added cProperty::getValueOriginFile(), getValueOriginType().
  • Fix: Build errors on newer versions of clang.
  • Fix #933: eventlog recording intervals were ignored.
  • Fix: Check for context component in all built-in NED functions that need it and throw an exception if there is none, instead of just crashing.
  • IDE:
  • CDT component upgraded to 10.6.2
  • Fix #938: Filtering the eventlog in the sequence chart makes it empty.
  • Fix #896: NED visual editor cannot show warning symbol.
  • Fix #634: NED files in search results now open properly in NED editor.
  • Fix #932: Exception when the filter button was clicked on the Sequence Chart window.
  • Fix #936: Illegible text on build output console in dark mode.
  • Analysis Tool:
  • Various fixes in the Python analysis package.
  • Added the python/ folders of referenced project(s) to Python path of chart scripts.
  • On Windows, the bundled Python was upgraded to 3.10, fixing several issues in NumPy and Matplotlib.
  • NED Documentation Generator:
  • Refined support for msg types with namespace.
  • Added support for "@debug links" page directive.
  • Made namespaces appear in the navigation tree.
  • Qtenv:
  • Fix: Non-working parameter replacements in channel display strings.
  • Fix: Missing logs with disabled event/initialization banners.
  • Fix #934: Eliminate assertion failure on stopping eventlog recording from Qtenv.
  • Fix: Clamp nonzero computed animation speed to at least 1e-9. (Very low animation speed could result in simulation time not progressing at all, due to finite precision in the computations.)
  • Various other minor bug fixes.
  • Documentation:
  • Minor corrections in the Installation Guide.
  • Updated documentation for the omnetpp.scave Python classes.
  • Document fingerprint ingredients added in 6.0.

New in OMNeT++ 6.0 (May 21, 2022)

  • OMNeT++ 6.0 is the result of more than three years of work, and includes many essential new features that we would already have a hard time without. The present changelog summarizes all changes made during the 15+ pre-releases.
  • We briefly summarize the changes below in each part of OMNeT++ before going into the details.
  • The most prominent new feature is the new Python-based Analysis Tool in the IDE. The use of Python under the hood allows for arbitrarily complex computations to be performed on the data, visualizing the result in the most appropriate form chosen from a multitude of plot types, and producing publication quality output, all while using an intuitive user interface that makes straightforward tasks easy and convenient. Custom computations and custom plots are also easily accessible. The tool is able to handle large quantities of data. The Python APIs are also available outside the IDE (e.g. for standalone scripts), and a command-line tool for viewing and exporting charts created in the IDE also exists (opp_charttool).
  • The NED language now supports parameters that carry C++ objects as values (type object), which can be used to parameterize modules with structured data (e.g. nontrivial configuration), packet prototypes, function objects, etc. Structured data may come from NED functions like readCSV() or readJSON() which parse data files, or may be specified directly in NED or ini files using JSON syntax. The syntax of ini files has even been adjusted to make it more convenient to write multi-line JSON values in it. Further new functionality includes the string match operator =~, the "spaceship" operator <=>, and support for Universal Function Call Syntax (UFCS). Incompatible changes include the change in the interpretation of parameter names that are not qualified with the this or parent keywords, and the necessity to mark module parameters with @mutable that are allowed to be set at runtime. Embedding NED files into simulation binaries for easier dissemination has also become possible.
  • Message descriptions (msg files) have undergone even bigger changes. An import system has been added to make the content of a msg file available in others. The generated code and class descriptors can now be widely customized via properties. Targeted C++ blocks have been introduced for injecting C++ code into various places in the generated source files. Altogether, these (and further, smaller) features facilitate writing significantly cleaner msg files, especially in large projects like INET.
  • The format of ini files have been made more flexible: the Config word in section headers is now optional, and long lines can be broken up to multiple lines without using trailing backslashes (just indent the continuation lines).
  • In the simulation kernel, the most important change is the introduction of the Transmission Updates API, which allows in-progress packet (frame) transmissions to be modified, i.e. aborted, shortened, or extended. This API is necessary for implementing L2 features like frame preemption or on-the-fly frame aggregation. Other changes include the addition of utility APIs like scheduleAfter(), rescheduleAt() and rescheduleAfter(), refinements around module deletion and the introduction of the preDelete() virtual member function, refinements in the signals and listeners APIs, improved expression evaluation support, and the addition of string-handling utility functions, just to name a few.
  • Regarding statistics recording, perhaps the most significant addition is the demux filter, which allows splitting a single stream (of emitted values) to multiple streams. The filter makes it possible to record statistics subdivided by some criteria, e.g. to record statistics per TCP connection, per remote IP address, per traffic class, etc., in INET. Further improvements include the addition of the warmup filter and the autoWarmupFilter statistic attribute that allow computed statistics to be calculated correctly also in the presence of a nonzero warm-up period. Result files now hold more metadata: parameter values and configuration entries are now also (optionally) recorded. This change, together with other, smaller adjustments, cause new result files not be understood by previous versions of OMNeT++.
  • A significant amount of work has been put into improving the looks and functionality of Qtenv: material-style icons, HIDPI support, dark theme support, and countless small features that improve usability, especially around the Object Inspector and the Log View. For example, it is now possible to set the Messages view of the Log to display all timestamps as a delta to a user-specified reference timestamp; or, the Object Inspector now allows selecting a different display mode for a tree node. One important change is that method call animations are now disabled by default.
  • The Sequence Chart tool in the IDE has been significantly improved, both visually and functionally, with the goal of allowing the user to configure the chart in a way that facilitates understanding of the sequence of events in the simulation. The tools provided for that purpose are the possibility to hide unnecessary elements (unrelated arrows, events, etc), support for user-defined coloring, interactively collapsible compound module axes, horizontally expanded events so that the arrows of nested method calls do not overlap, and more. The eventlog file format has also changed in a non-backward-compatible way, due to the addition of extra elements that allow the Sequence Chart tool to be faster and more scalable.
  • Generating documentation from NED and MSG files has been made possible from the command line as well, using the new opp_neddoc tool. Functionality has been extended with the possibility of incorporating external information into the generated pages.
  • The C++ debugging experience has been made more pleasant in several ways. For example, the "Debug on Error" and "Debug Next Event" functionality in Qtenv may now invoke the integrated debugger of the Simulation IDE, which is especially useful when the simulation was launched from the IDE. The User Guide also contains a hint on how to configure simulations to invoke VS Code as debugger.
  • Due to improvements in the toolchain and the build process, Windows users may see the linking time of large models like INET Framework to drop dramatically (1-2 orders magnitude, e.g. from several minutes to several seconds). On macOS, Apple Silicon, is currently supported with x86-64 emulation.
  • Now, the details:
  • NED:
  • Semantics change: Within a submodule's or connection's curly brace block, the interpretation of parameter, gate, and submodule references that don't use an explicit parent or this qualifier has changed. They no longer refer to the enclosing compound module's item, but to the item of (or within) the local submodule or channel object. The interpretation of item references outside subcomponent blocks has remained unchanged. An example:
  • network Network {
  • parameters:
  • int foo;
  • submodules:
  • node1: { ... }
  • node2: Node {
  • foo = foo; // ERROR: self-reference! Change to 'foo=parent.foo'.
  • bar = this.foo; // OK
  • baz = node1.foo; // ERROR: refers to yet-uncreated submodule node2.node1!
  • bax = parent.node1.foo; // OK
  • The set of forms accepted by exists() and sizeof() has been expanded. Notably, exists() can now be used to check the existence of an item in a submodule vector (as submodule vectors may now contain holes, due to @omittedTypename). Also, the index() syntax has been removed, index is only accepted without parens.
  • Note that referencing a submodule's submodule from NED (i.e. the a.b or this.a.b syntax within a submodule block) is generally wrong, because the network is built top-down, and submodules are only created after parameters have already been set up. (An exception is using it in the values of volatile parameters, because they are evaluated later.)
  • Error messages have been revised and expanded to be more helpful and facilitate porting NED code from 5.x.
  • To write NED which is compatible with both OMNeT++ version 5.x and 6.0, qualify all references within subcomponent blocks with explicit parent or this, and require OMNeT++ 5.7 which is the first and only 5.x version that understands the parent keyword.
  • NED grammar: Added object as parameter type. Parameters of this type may hold objects subclassed from cOwnedObject that they can take ownership of.
  • NED parameters of type object may have a @class() property, with the syntax @class(classname) or @class(classname?). The property specifies that the parameter should only accept objects of the given type and its subclasses. The referenced class must be registered via Register_Class() or Register_Abstract_Class(). Parameters declared without the question mark in @class() don't accept nullptr as value, while the ones with question mark do.
  • The NED expression syntax has been extended to accept JSON-style constructs, i.e. arrays and dictionaries (termed "object" in JSON), and the nullptr keyword. The array syntax is a list of values enclosed in square brackets, for example [1, 2, 3], and the array is accessible as a cValueArray object in C++. The dictionary syntax uses curly braces: {"foo" : 1, "bar" : 2 }, and dictionaries are presented as cValueMap objects. If a dictionary is prefixed by a name, then the name is interpreted as a class name, and values are interpreted as fields of the object: cMessage { name: "hello", kind: 1}.
  • Object parameters allow simple values (int, double, bool, string) as well. C++-wise, they are stored in the parameter in cValueHolder-wrapped cValue objects.
  • New NED functions have been introduced: get() (return an element of an array or dictionary), size() (returns the size of an array or dictionary), eval() (evaluates a NED expression given as string), dup() (clones an object). dup() simply calls an object's C++ dup() method; it is useful because module parameters of type object only accept objects they fully own, which can be worked around using dup(). An example:
  • Object a = [1,2,3];
  • Object b = dup(a); // without dup() it is an error: value is owned by parameter 'a'
  • As dup() invoked on containers only duplicates the objects owned by the container, you may need extra dup() call when referring to objects owned by other parameters. Example:
  • Object a = {};
  • Object b = dup([a,a]); // ERROR (a's inside the array are not cloned)
  • Object c = [dup(a), dup(a)] // OK
  • NED grammar: Made operator precedence more similar to C/C++. Relational operators (==, !=, <, <=, >, >=) used to be on the same precedence level; now == and != have lower precedence than the rest.
  • NED grammar: Added the =~ (match) and <=> (comparison, a.k.a. "spaceship") operators, the undefined keyword, and bool() as conversion function.
  • String constants are now accepted with apostrophes too. This makes it possible to write quotation marks in strings without the need to escape them.
  • For quantities (numbers with measurement units), the rules have changed slightly. When specifying quantities with multiple terms, a minus sign is only accepted at the front, to reduce the chance of confusion in arithmetic expressions. I.e. -5s100ms is valid as a quantity string (and means -5.1s), but 5s-100ms is no longer.
  • Also, the plain "0" constant is no longer accepted at places where a quantity with a measurement unit is expected. Reason: it was confusing when the expected unit was dB or dBm. E.g. in omnetpp.ini, should **.power = 0 be interpreted as 0W or 0dBm?
  • Added support for Universal Function Call Syntax (UFCS) to NED, which means that now any function call may also be written as if the function was a method of its first argument (provided it has one). That is, f(x,..) can now be also written in the alternative form x.f(...). This results in improved readability in certain cases, and allows chaining function calls.
  • Xmldoc() (and other file-reading functions) now interpret the file name as relative to the directory the expression comes from. When xmldoc() occurs in an included ini file, the file name is now interpreted as relative to the directory containing the included ini file (as opposed to being relative to the main ini file or the working directory.) If xmldoc() occurs in a NED file, the file name is relative to the directory where that NED file was loaded from.
  • NED functions for reading (from file) and parsing (from string) of CSV, JSON and XML files: parseCSV(), readCSV(), parseExtendedCSV(), readExtendedCSV(), parseJSON(), readJSON(), parseExtendedJSON(), readExtendedJSON(), parseXML(), readXML(). The "extended" variants support expressions in the file, which will be evaluated during parsing. The XML functions are aliases to the existing xml()/xmldoc() functions. Bonus file-related functions: readFile(), workingDir(), baseDir(), resolveFile(), absFilePath().
  • The body of a parametric submodule now allows assigning apparently nonexistent parameters. For example, in the example below, the sleepTime assignment does not cause an error if FooApp has a sleepTime parameter but IApp does not:
  • App: <default("FooApp")> like IApp {
  • Parameters:
  • Address = parent.address;
  • SleepTime = 1s; // ignored if app has no 'sleepTime' parameter
  • Implemented @omittedTypename property. @omittedTypename allows one to specify a NED type to use when typename="" is specified for a parametric submodule or channel. @omittedTypename can be specified on a module interface or channel interface, or on a submodule or connection. It should contain a single (optional) value. The value names the type to use. If it is absent, the submodule or channel will not be created. (The connection will be created without a channel object.)
  • The @mutable property was introduced for parameters. If the module (or channel) is prepared for a parameter to change its value at runtime (i.e. the new value takes effect), then it should be marked with @mutable. If @mutable is missing, then trying to change the parameter will now result in a runtime error ("Cannot change non-mutable parameter".)
  • The motivation is that in a complex model framework, there is usually a large number of (module or channel) parameters, and so far it has not been obvious for users which parameters can be meaningfully changed at runtime. For example, if a simple module did not implement handleParameterChange() or the handleParameterChange() method did not handle a particular parameter, then the user could technically change that NED parameter at runtime, but the change did not take effect. This has often caused confusion.
  • Parameters of ned.DelayChannel and ned.DatarateChannel are now marked @mutable.
  • To allow running existing simulation models that have not yet been updated with @mutable annotations, we have added the parameter-mutability-check configuration option. Setting parameter-mutability-check=false will give back the old behavior (not raising an error).
  • Added the expr() operator to NED, with the purpose of allowing models to accept formulas or expressions which it could use e.g. to determine the processing time of a packet based on packet length or other properties, decide whether a packet should be allowed to pass or should be filtered out based on its contents (filter condition), or to derive x and y coordinates of a mobile node in the function of time.
  • The argument to expr() is a NED expression which will typically contain free variables, (like x and y in expr(x+y)). The expr() operator creates an object that encapsulates the expression, so it can be assigned to parameters of the type object. On the C++ side, the module implementation should query the parameter to get at the expression object (of type cOwnedDynamicExpression), and then it may bind the free variables and evaluate the expression as often as it wishes.
  • In xml() and xmldoc() element selectors, $MODULE_INDEX, $PARENTMODULE_NAME and similar variables now evaluate to the empty string if they are not applicable, instead of raising an error that was often problematic.
  • Improved error reporting during network building: when an error occurs during assigning a parameter from a NED file, the error message now includes the location of the assignment (file:line in NED file).
  • MSG:
  • Made the hitherto experimental operation mode and feature set of the message compiler official. This feature set was originally added around OMNeT++ 5.3, and could be enabled by passing the --msg6 option to opp_msgtool. There was also a no-op --msg4 option that selected the old (OMNeT++ 4.x compatible) operation. Most of the OMNeT++ 6.0 pre-releases shipped with the new operation mode being the default (i.e. --msg6 became a no-op), with features continually being added and refined. Then, finally, the old code and the --msg4 option were removed altogether.
  • The new operation mode represents a complete overhaul of the message compiler, with significant non-backward-compatible changes to the MSG language. These features were largely motivated by the needs of INET 4.
  • The message compiler is now aware of the OMNeT++ library classes, as if they were imported by default. Declarations come from sim_std.msg.
  • Added import support. A message file can now reference definitions in other message files using the import keyword. Type announcements are no longer needed (in fact, they are ignored with a warning), and there is now much less need for cplusplus blocks as well.
  • Classes without an extends clause no longer have cObject as their default base class. If cObject should be the base class, extends cObject needs to be added explicitly.
  • Field getters now return const reference. Separate get..ForUpdate() getters that return non-const are generated to cover uses cases when the contained value (typically an object) needs to be modified in-place.
  • Added targeted cplusplus blocks, with the syntax of cplusplus(<target>) {{..}}. The target can be h (the generated header file -- the default), cc (the generated C++ file), <classname> (content is inserted into the declaration of the type, just before the closing curly bracket), or <classname>::<methodname> (content is inserted into the body of the specified method). For the last one, supported methods include the constructor, copy constructor (use Foo& as name), destructor, operator=, copy(), parsimPack(), parsimUnpack(), etc., and the per-field generated methods (setter, getter, etc.).
  • Enum names can now be used as field type name, i.e. int foo @enum(Foo) can now be also written as Foo foo.
  • Support for const fields (no setter generated/expected).
  • Support for pointer and owned pointer fields. Owned pointers are denoted with the @owned field property. Non-owned pointers are simply stored and returned; owned pointers imply delete-in-destructor and clone-on-dup behavior. Owned pointer fields have a remover method generated for them (removeFoo() for a foo field, or removeFoo(index) if the foo field is an array). The remover method removes and returns the object in the field or array element, and replaces it with a nullptr. Additionally, if the object is a cOwnedObject, take() and drop() calls are also generated into the bodies of the appropriate methods. There is also an @allowReplace property that controls whether the setter method of an owned pointer field is allowed to delete the previously set object; the default is @allowReplace(false).
  • More convenient dynamic arrays: inserter, appender and eraser methods are now generated into the class. For example insertFoo(index,value), appendFoo(value), and eraseFoo(index) are generated for a foo[] field.
  • Support for pass-by-value for fields. Annotate the field with @byValue for that. @byValue and many other properties can also be specified on the class, and they are inherited by fields that instantiate that type.
  • Additional C++ base classes may be specified with the @implements property.
  • The @str property causes an str() method to be generated; the expression to be returned from the method should be given in the value of the property.
  • The @clone property specifies code to duplicate (one array element of) the field value.
  • The @beforeChange class property specifies the name of a method to be called from all generated methods that mutate the object, e.g. from setters. It allows implementing objects that become immutable ("frozen") after an initial setup phase.
  • The @custom field property causes the field to only appear in descriptors, but no code is generated for it at all. One can inject the code that implements the field (data member, getter, setter, etc.) via targeted cplusplus blocks.
  • The @customImpl field property, suppresses generating implementations for the field's accessor methods, allowing custom implementations to be supplied by the user.
  • Added the @abstract field and class property. For a field, it is equivalent to the abstract keyword; for classes, it marks the whole class as abstract.
  • Abstract fields no longer require the class to be marked with @customize.
  • Message files now allow more than one namespace <namespace>; directive. The namespace; syntax should be used to return to the toplevel C++ namespace.
  • The names of generated method can be overridden with the following field properties: @setter, @getter, @getterForUpdate, @sizeSetter, @sizeGetter, @inserter, @eraser, @appender, @remover, etc.
  • Data types can be overridden with the following properties: @cppType, @datamemberType, @argType, @returnType, @sizeType.
  • Changed C++ type for array sizes and indices, i.e. the default of @sizeType, from int to size_t.
  • Added support for setting pointer members and array sizes via class descriptors. (cClassDescriptor had no facility for that.) This involves adding two methods to cClassDescriptor (setFieldArraySize() and setFieldStructValuePointer()), and support for the @resizable() and @replaceable field attributes that tell the message compiler to generate the respective code in the class.
  • The @toString and @fromString properties specify a method name or code fragment to convert the field's value to/from string form in class descriptors (getFieldValueAsString() and setFieldValueFromString() methods of cClassDescriptor). In the absence of @toString, previous versions converted the value to string by writing it to a stream using operator<<; now the str() method of the object is used if it has one. If neither @toString nor str() exist, an empty string is returned.
  • Likewise, the @toValue and @fromValue properties specify a method name or code fragment to convert the field's value to/from cValue form in class descriptors ((getFieldValue() and setFieldValue() methods of cClassDescriptor)).
  • Better code for generated classes, e.g. inline field initializers, and use of the =delete syntax of C++11 in the generated code.
  • Better code generated for descriptors, e.g. symbolic constants for field indices.
  • The list of reserved words (words that cannot be used as identifiers in MSG files; it is the union of the words reserved by C++ and by the MSG language) has been updated.
  • A complete list of supported properties (not all of them are explicitly listed above) can be found in an Appendix of the Simulation Manual.
  • Ini files:
  • It is now possible to break long lines without using a trailing backslash. Continuation lines are marked as such by indenting them, i.e. an indented line is now interpreted as a continuation of the previous line. (It is not possible to break a line inside a string constant that way.) Breaking lines using a trailing backslash way still works (and it can also be used to break string constants, too). Indentation-based line continuation has the advantage over backslashes that it allows placing comments on intermediate lines (whereas with backslashes, the first # makes the rest of the lines also part of the comment).
  • The Config prefix in section headers is now optional, that is, the heading [Config PureAloha] may now be also written as [PureAloha], with the two being equivalent.
  • Simulation kernel / Modules, channels, programming model:
  • Added the scheduleAfter(), rescheduleAt(), rescheduleAfter() methods to cSimpleModule. They are mainly for convenience, but using rescheduleAt() instead of cancelEvent() + scheduleAt() will eventually allow for a more efficient implementation.
  • Change in the parameter change notification mechanism: Calls to the handleParameterChange() method during initialization are no longer suppressed. Because now every change results in a notification, the umbrella handleParameter(nullptr) call at the end of the initialization is no longer needed and has been removed. The consequence is that handleParameterChange() methods need to be implemented more carefully, because they may be called at a time when the module may not have completed all initialization stages. Also, if an existing model relied on handleParameter(nullptr) being called, it needs to be updated.
  • Improvements in the multi-stage initialization protocol with regard to dynamic module creation. Modules now keep track of the last init stage they completed (lastCompletedInitStage). During an init stage, initialization of modules is restarted if creation/deletion is detected during iteration; modules already initialized in the previous round are recognized and skipped with the help of lastCompletedInitStage.
  • CModule now keeps track of submodule vectors as entities, and not just as a collection of submodules with vector indices, meaning that we can now distinguish between nonexistent and zero-size submodule vectors. Random access of vector elements has also became more efficient (constant-time operation). Several new methods have been added as part of this change: hasSubmoduleVector(), getSubmoduleVectorSize(), addSubmoduleVector(), deleteSubmoduleVector(), setSubmoduleVectorSize(), getSubmoduleVectorNames().
  • As part of the above change, several cModule and cModuleType methods have been added or updated. A partial list:
  • In cModule, the hasSubmodule(), getSubmoduleNames(), hasGateVector(), hasGates() methods have been added for consistency between submodule and gate APIs.
  • The return type of the getGateNames() method has been changed from std::string<const char*> to std::vector<std::string>, for consistency with getSubmoduleNames().
  • CModule: added setIndex() and setNameAndIndex().
  • CModule, cGate: getIndex(), getVectorSize(), gateSize() and similar methods now throw exception for non-vector submodules/gates.
  • CModule: add separate addGateVector() method instead misusing addGate() for creating gate vectors, also for consistency with addSubmoduleVector().
  • In cModuleType::create(), the vectorSize parameter of create() has been removed.
  • In cModuleType::createScheduleInit(), an index argument was added to allow creating submodule vector elements.
  • CModule: added addSubmodule() method which flows more naturally than cModuleType::create().
  • There have been changes in submodule and channel iterators. SubmoduleIterator has been rewritten due to the change in how submodule vectors are represented, which may affect the iteration order in some cases. Iterators now throw an exception if a change occurs in the list of submodules/channels during iteration. Their APIs have also changed a little: operator-- was removed, and init(m) was renamed to reset().
  • Optimized cModule::ChannelIterator by letting cModule maintain a linked list of channels (cChannel), so that ChannelIterator doesn't have to search through the whole compound module to find them.
  • Module name and full name (i.e. "name[index]") are now stringpooled, which reduces memory usage in exchange for a small build-time extra cost. In addition, string pools now use std::unordered_map instead of std::map, which results in improved performance.
  • CComponent: added getNedTypeAndFullName() and getNedTypeAndFullPath(). They are especially useful in constructing error messages in NED functions.
  • Simulation kernel / Signals and notifications:
  • Intpar_t was renamed to intval_t, and uintval_t was added. Both are guaranteed to be at least 64 bits wide.
  • Signal listeners changed to use intval_t and uintval_t instead of long and unsigned long. This change was necessary because long is only 32 bits wide on Windows. This affects methods of cListener and subclasses like cResultFilter and cResultRecorder.
  • Emitting nullptr as a string (const char* overload of emit()) is disallowed. The reason is that nullptr cannot be represented in std::string, which causes problems e.g. in result filters and recorders.
  • Added two new model change notifications: cPostModuleBuildNotification, cPostComponentInitializeNotification.
  • Minor changes in some model change notification classes. In cPreModuleAddNotification, the vectorSize field was removed (as it was redundant), and in cPostModuleDeleteNotification, the interpretation of the index field has changed a little: if the deleted module was not part of a module vector, index is now set to -1 instead of 0.
  • Simulation kernel / Utilities:
  • Two utility functions were added to cObject: getClassAndFullPath() and getClassAndFullName(). They are mostly useful in logging and error messages.
  • CMatchExpression: The field =~ pattern syntax replaces field(pattern). Also removed the implicit OR syntax. The old syntaxes looked confusing, and made it difficult to tell apart the concise notation from expression-style notation.
  • Simulation kernel / Utilities:
  • Added opp_component_ptr<T>. It implements a smart pointer that points to a cComponent (i.e. a module or channel), and automatically becomes nullptr when the referenced object is deleted. It is a non-owning ("weak") pointer, i.e. the pointer going out of scope has no effect on the referenced object. opp_component_ptr<T> can be useful in implementing modules that hold pointers to other modules and want to be prepared for those modules getting deleted. It can also be useful for simplifying safe destruction of compound modules containing such modules.
  • New classes: opp_pooledstring, opp_staticpooledstring. They provide pool- backed string storage (reference-counted and non-reference-counted, respectively). In turn, the cStringPool class was removed; use either of the pooled string classes or or opp_staticpooledstring::get(const char *) instead.
  • Several string functions have been made available for models. A representative partial list: opp_isempty(), opp_isblank(), opp_nulltoempty(), opp_trim(), opp_split(), opp_splitandtrim(), opp_join(), opp_stringendswith(), opp_substringbefore(), etc.
  • The cStringTokenizer class has been rewritten. It now supports features like optional skipping of empty tokens, optional trimming of tokens, optional honoring of quotes, optional honoring of parens/braces/brackets (i.e. the input string is not broken into tokens in the middle of a parenthesized expression).
  • Simulation kernel / Visualization support:
  • Added display name support to modules. Display name is a string that optionally appears in Qtenv next to (or instead of) the normal module name, in order to help the user distinguish between similarly-named submodules. For example, application-layer modules app[0], app[1], etc. in INET may be given descriptive names like "file transfer", "video", "voice", or "CBR", and have them displayed in Qtenv. Display names may be set using the display-name per-module configuration option, or programmatically by calling setDisplayName().
  • Added the g=<group> (layout group) display string tag, which makes it possible to apply predefined arrangements like row, column, matrix or ring to a group of unrelated submodules. This layouting feature was previously only available for submodule vectors. When "g" tags are used, submodules in the same group are now regarded for layouting purposes as if they were part of the same submodule vector.
  • Made it possible to specify display strings in the configuration. The value given in the display-string per-component configuration option is merged into the component's display string in the same way inheritance or submodule display strings work: it may add, overwrite or remove items from it.
  • Added text alignment support to text and label figures: cFigure::Alignment enum, getAlignment()/setAlignment() in cAbstractTextFigure.
  • Added the toAlpha() method and a constructor taking Color to cFigure::RGBA.
  • Simulation kernel / Transmission updates:
  • The initial send() is interpreted as: "packet transmission begins now, packet content and duration are, as things are now, going to be this".
  • Following that, an "update" (or any number of updates) can be sent. An update is a packet with the updated ("actual") content, and with a "remaining transmission duration" attached. Updates may only be sent while transmission is still ongoing.
  • As an example, aborting a transmission is done by sending a packet with a truncated content and a remaining duration of zero.
  • Transmission updates are paired with the original packet they modify using a transmissionId. The transmissionId is normally chosen to be the packet ID of the original transmission. Channels should understand updates and handle them accordingly.
  • Receivers that receive the packet at the end of the reception, which is the default operating mode, will only receive the final update. The original packet and intermediate updates are absorbed by the simulation kernel.
  • Receivers that receive the packet at the start of the reception (see cGate::setDeliverImmediately(), previously called setDeliverOnReceptionStart()) should be prepared to receive all of the original packet and the updates, and handle them appropriately. Tx updates can be recognized from cPacket::isUpdate() returning true. cPacket::getRemainingDuration() returns the remaining transmission duration, and cPacket::getDuration() the total transmission duration.
  • As a safeguard against unprepared modules accidentally processing tx updates as normal full-blown packets, the module is only given tx updates if it explicitly declares that it is able to handle them properly. The latter is done by the module calling setTxUpdateSupport(true) before receiving packets, e.g. in initialize().
  • Non-transmission channels treat tx updates in the same way as they treat any other messages and packets (they ignore the cPacket::isUpdate() flag).
  • Details and related changes follow.
  • Send() and sendDirect() now accept a SendOptions struct where optional parameters such as delay can be passed in. sendDelayed() and other send()/sendDirect() variants now convert their extra args to a SendOptions, and delegate to the "standard" send()/sendDirect() versions. SendOptions was introduced as a means to handle combinatorial explosion of send() variants.
  • For methods that participate in the send protocol (cGate::deliver(), cModule::arrived(), cChannel::processMessage()), SendOptions was added.
  • CDatarateChannel now allows the sender to explicitly specify the packet duration in SendOptions, overriding the duration that the channel would compute from the packet length and the channel datarate.
  • CDatarateChannel's datarate is now optional: set it to 0 or nan to leave it unspecified. This change was necessary to support transmitting frames with per-frame data rate selection. If the datarate is unspecified, the packet duration must be supplied in the send call, otherwise a runtime error will be raised.
  • CDatarateChannel: non-packet messages now pass through without interfering with packets.
  • CDatarateChannel: disabled channels now let transmission updates through, so that it is possible for the transmitter module to abort the ongoing packet transmission.
  • Tx updates (without duration/remainingDuration) are allowed on paths without transmission channels.
  • In cChannel::processMessage(), result_t was renamed cChannel::Result, and it is now a proper return value (not an output parameter).
  • RemainingDuration was added to cChannel::Result.
  • CDatarateChannel now optionally allows multiple concurrent transmissions, with or without any bookkeeping and associated checks. This is useful for modeling a channel with multiple subchannels or carriers. The operating mode has to be selected programmatically, with the channel's setMode() method. Possible modes are SINGLE, MULTI and UNCHECKED.
  • The forceTransmissionFinishTime() method of channels has been deprecated. It was always meant as a temporary device to allow implementing aborting frame transmissions, and now with the arrival of the new transmission update API there is no reason to use it any more. Simulations using it should be migrated to the new API.
  • Renamed setDeliverOnReceptionStart() to setDeliverImmediately().
  • Added cSimpleModule::supportsTxUpdates() flag.
  • CPacket now carries a remainingDuration field.
  • CPacket: eliminated FL_ISRECEPTIONSTART; isReceptionStart() now uses remainingDuration as input; added a similar isReceptionEnd() method.
  • CPacket::str() overhaul to reflect new fields and uses.
  • In the APIs, send delay and propagation delay, which were sort of combined into a single value, are now distinct values, handled separately.
  • Simulation kernel / Module deletion:
  • Added the preDelete() method to cComponent. This is an initially empty virtual function that the user can override to add tasks to be done before the module (or channel) is deleted. When deleteModule() is called on a compound module, it first invokes preDelete() for each module in the submodule tree, and only starts deleting modules after that. preDelete() can help simplify network or module deletion in a complex simulation that involves model change listeners.
  • CIListener's destructor now unsubscribes from all places it was subscribed to. This change was necessitated by the following deleteModule() change.
  • DeleteModule(): Module destruction sequence was changed so that when deleting a compound module, the compound module's local listeners are notified about the deletion of the submodules.
  • DeleteModule() internals refactored. The motivation was to avoid doing things like firing pre-model-change notifications from a halfway-deleted module. Now we do every potentially risky thing (such as deleting submodules and disconnecting gates) from doDeleteModule(), and only delete the module object when it is already barebones (no submodules, gates, listeners, etc). With this change, the deletion sequence is now pretty much the reverse of the setup sequence.
  • Now it is allowed for modules to be deleted (including self-deletion) and created at will during initialization.
  • Simulation kernel / Expressions, object parameters, JSON values:
  • Under the hood, all expression parsing and evaluation tasks now use the same new generic extensible expression evaluator framework. It is used for NED expressions, object matching, scenario constraint, statistics recording, result selection in the Simulation IDE and in opp_scavetool, in cDynamicExpression and cMatchExpression, etc. In the new framework, expression parsing and the translation of the AST to an evaluator tree are done in separate steps, which makes the library very versatile. Evaluators include support for shortcutting logical and conditional operators, constant folding, and an undefined value (anything involving undefined will evaluate to undefined).
  • CNedValue was renamed to cValue (compatibility typedef added), as it is now a generic value container used throughout the simulation kernel (cPar, cExpression, cClassDescriptor, etc.), i.e. it is no longer specific to NED.
  • CValue's doubleValue() and intValue() methods now throw an exception when called on a value that has a measurement unit, in order to reduce usage mistakes. If the value has a unit, call either doubleValueInUnit() / intValueInUnit(), or doubleValueRaw()/intValueRaw() plus getUnit().
  • CValue changed to hold any_ptr (see later) instead of cObject*. This change involves several changes, e.g. type OBJECT renamed to POINTER, and pointerValue() added.
  • CPar: Added support for object parameters. New type constant: OBJECT. New methods: setObjectValue(), objectValue(), operator=(cObject*), operator cObject*.
  • CPar: Added cValue-based generic access: getValue(), setValue().
  • Store origin (file:line) info in cPar parameters (more precisely, in cDynamicExpression), so we can report it on evaluation errors. Most visible change: cPar::parse() gained an extra FileLine argument. Also, cDynamicExpression now has get/setSourceLocation().
  • Added cValueArray and cValueMap classes for representing JSON data in NED expressions. A third class is cValueHolder, a wrapper around cValue, which is only used when a non-object value (double, string, etc) is assigned to a NED parameter of the type object. All three classes subclass from cValueContainer. Note that behavior of the dup() methods of cValueArray and cValueMap is consistent with that of cArray and cQueue, i.e. only those objects that are owned by the cloned container are duplicated.
  • NED functions that take or return values of type object are now allowed.
  • NED functions can now be defined with the alternative signature:
  • CValue f(cExpression::Context *context, cValue argv[], int argc)
  • In addition to the existing signature
  • CValue f(cComponent *contextComponent, cValue argv[], int argc)
  • The cExpression::Context argument allows one to access the context component, and also the directory where the ini file entry or the NED file containing the expression occurred (the "base directory"). Define_NED_Function() accepts both signatures. The base directory is useful for functions like xmldoc() that want to access files relative to the location of the NED expression.
  • CNedFunction now allows to search for NED functions by name AND accepted number of args.
  • CDynamicExpression has been reimplemented using the new internal Expression class, and support for user-defined variables, members, methods, and functions was added. As a consequence, the public interface of the class has significantly changed as well.
  • Added the cOwnedDynamicExpression class which holds the result of a NED expr() operator. cOwnedDynamicExpression is both cOwnedObject and cDynamicExpression (multiple inheritance). To make this possible, the cObject base class was removed from cExpression.
  • CClassDescriptor: Use exception instead of returning false for indicating error. The return types of the following methods changed from bool to void: setFieldValueAsString(), setFieldArraySize(), setFieldStructValuePointer().
  • CClassDescriptor: Added support for setting pointer members and array sizes via class descriptors. New methods: setFieldArraySize(), setFieldStructValuePointer().
  • CClassDescriptor: Added getFieldValue()/setFieldValue() methods to allow accessing fields in a typed way, using cValue. Previously existing methods getFieldValueAsString()/setFieldValueAsString() only allowed string-based access. In MSG files, the @toValue() and @fromValue() properties can be used to provide code to convert objects or fields to cValue.
  • CClassDescriptor: Methods changed to use any_ptr instead of void* for passing the object. (any_ptr is a smart pointer class that provides type safety for void* pointers.) Pointers need to be put into and extracted from any_ptr using the new toAnyPtr() / fromAnyPtr() functions. They have specialized versions for each type (via templates and overloading). For new types, the message compiler generates toAnyPtr()/fromAnyPtr() in the header file. For the simulation library classes, these methods come from sim_std_m.h (generated from sim_std.msg); sim_std_m.h is now part of <omnetpp.h>.
  • Simulation kernel / Fingerprints:
  • Due a bugfix in cHasher::add(const char *), fingerprints that involve hashing strings changed their values.
  • The implementation of cHasher::add(const std::string&) was changed to be consistent with the add(const char *) overload. This may cause fingerprint changes in models that use it.
  • Changed the way fingerprints are computed from figures. Most importantly, fingerprints are now affected by all visual properties, not just geometry information. This change only affects fingerprints that contain the 'f' (=figures) ingredient.
  • The introduction of the new expression evaluation framework also somewhat affects fingerprints. The fact that logical operators and inline-if are now shortcutting may change the fingerprint of some simulations, due to consuming fewer random numbers during expression evaluation.
  • Simulation kernel / Miscellaneous:
  • The getModuleByPath() method was changed to never return nullptr, even if an empty string is given as path. Instead, it will throw an exception if the module was not found. This change makes this method consistent with other getter methods in the simulation library, and allows nullptr checks to be removed from model code that uses it. A new method, findModuleByPath() was added for cases when an optionally existing module needs to be found. These methods, initially defined on cModule, have been moved to cComponent so that they can be called on channels too.
  • Signature change of the cVisitor::visit(cObject *obj) virtual method: it can now request end of iteration via returning false (hence, return type changed from void to bool) instead of throwing EndTraversalException. Existing cVisitor subclasses in model code will need to be adjusted.
  • CPar: Implemented isMutable() and the mechanism behind the new @mutable property.
  • CProperty: Added getNumKeys() method; updateWith() made public.
  • CConfiguration: Removed getParameterKeyValuePairs(). Instead, getKeyValuePairs() made smarter with an extra flags parameter to be able to handle the various use cases.
  • CMessage: Allowed isMessage() to be called from subclasses.
  • CEnvir: New result recording related methods: recordComponentType(), recordParameter().
  • CEnvir: Added getConnectionLine(), which returns the coordinates of a connection arrow. This is for certain custom animations.
  • CEnvir: Added pausePoint(), an animation-related experimental API.
  • Result filters: Two new methods in the cResultListener interface: emitInitialValue() and callEmitInitialValue().
  • CResultFilter, cResultRecorder: Grouped init() args into a Context struct, The old init() methods have been preserved as deprecated (and invoked from the new init()) in case an existing filter/recorder overrides them. Note that potential external calls to the old init() method won't work any more (they will have no effect), and need to be changed to the new version.
  • Added MergeFilter, a result filter that allows multiple inputs, and multiplexes them onto its singe output. It is available (as the merge() function) in the source= part of @statistic.
  • Fixed histogram loading issue in the output scalar file (.sca). Bin edges that are very close could become equal in the file if insufficient printing precision was set, rendering the file unreadable. The issue is now handled both during result file writing (if such condition is detected, bin edges are written with full [16-digit] precision) and reading (zero-width bins are merged into adjacent nonzero-width bin).
  • Simulation kernel / Cleanup:
  • Removed obsolete/deprecated classes and methods. A partial list: cVarHistogram, cLegacyHistogram, cLongHistogram, cDoubleHistogram, cWeightedStdDev, cDensityEstBase; detailedInfo() method; timeval_*() functions; cHistogram methods setRangeAuto(), setRangeAutoLower(), setRangeAutoUpper(), setNumCells(), setCellSize(); operator() of iterator classes in cArray/cModule/cQueue; cFigure/cCanvas deprecated methods addFigureAbove() and addFigureBelow(); many cAbstractHistogram (ex-cDensityEstBase) methods, etc. Instead of the removed timeval_*() methods, use opp_get_monotonic_clock_usecs() or opp_get_monotonic_clock_nsecs(), and perform the arithmetic in int64_t.
  • Refactoring: Some classes, methods and variables related to ownership management were renamed: cDefaultOwner -> cSoftOwner; defaultOwner -> owningContext, etc.
  • The setPerformFinalGC() method was removed. It was meant for internal use, and pretty much unused by model code.
  • Removed the support for OMNeT++ 4.x fingerprints (USE_OMNETPP4x_FINGERPRINTS).
  • WITH_OMNETPP4x_LISTENER_SUPPORT was removed.
  • Source code modernization: use in-class member initializers wherever possible. The source code now requires a C++14 compiler.
  • Internal classes, global variables, etc moved into the omnetpp::internal namespace.
  • Runtime:
  • Accept expressions as value for (most) config options. For options that accept values both with and without quotes (types STRING, FILENAME, FILENAMES, PATH), a heuristic decides whether a string is to be taken literally or to be evaluated as an expression. Expressions may also use NED operators, module parameters and other NED expression features. For example, it is possible to use the module vector index in the value of the display-name option: **.app[0..3].display-name = "cbr-" + string(index)
  • Allow parameter values to be specified on the command line. For example, --**.mss=512 is equivalent to inserting the **.mss=512 line near the top of the configuration in omnetpp.ini.
  • Do not complain about missing omnetpp.ini if a --network command-line option is present.
  • There were several improvements related to the NED path. The NEDPATH environment variable has been renamed to OMNETPP_NED_PATH, but the old one is still recognized for backward compatibility. Multiple -n options are now accepted. Also, the NEDPATH environment variable used to be ignored when a -n option was present, no longer so. Excluding packages from NED file loading has also been implemented. NED exclusions can be specified in multiple ways: the -x <packagelist> command-line option, the OMNETPP_NED_PACKAGE_EXCLUSIONS environment variable, and the ned-package-exclusions configuration option (they accept semicolon- separated lists).
  • Change in NED loading: Now, if a package has files in several distinct source trees, only one of them may contain a package.ned file.
  • There were also several improvements related the image path. The -i <imgpath> option command-line option has been added. It may occur multiple times. The image path is now defined jointly by the OMNETPP_IMAGE_PATH environment variable, -i command-line options, and the image-path configuration option. ./bitmaps was removed from default image path, as it was virtually unused. The default value ./images now comes from the default value of the image-path configuration option.
  • Added support for embedding NED files into a binary (an executable or library). The cpp subcommand of opp_nedtool generates C++ code that contains the content of NED files as string constants, which can then be compiled into the simulation binary. When the simulation program is started, these embedded NED files will be loaded automatically, and the original NED files will no longer be needed for running simulations. Optional garbling, which prevents NED source code from being directly readable inside the compiled binaries, is also available. A makefrag file can be used to integrate the NED-to-C++ translation into the build process. To see an example makefrag file, view the makefrag help topic in opp_nedtool.
  • Several global config options were changed to be per-run: scheduler-class, debug-on-errors, print-undisposed, fingerprintcalculator-class.
  • Added the parsim-num-partitions config option, which makes it possible to explicitly declare the number of partitions to be used with parallel simulation. (Before, it was explicitly taken by OMNeT++ from MPI or the respective communication layer.)
  • Added the config-recording configuration option, which controls the amount of configuration options to save into result files.
  • Allow recording actual module/channel parameter values into the output scalar file, via the new param-recording per-object boolean configuration option. Note that parameters will be recorded as "parameter" result items, not as scalars. For volatile parameters, the expression itself will be recorded (e.g. exponential(0.5)), not any particular value drawn from it.
  • Added support for result directory subdivision: the resultdir-subdivision boolean configuration option and the ${iterationvarsd} variable. The motivation is that the performance of various file managers (including Eclipse's Project Explorer) tends to degrade severely if there are more than a few thousand files in a single directory. In OMNeT++, this problem occurs when a parameter study produces a large number of result files. The common workaround is to "hash" the files into a subdirectory tree. (For example, git also uses this technique to store the contents of .git/objects dir).
  • In OMNeT++, such feature can be turned on by setting resultdir-subdivision= true in the configuration. Since it is natural to use the iteration variables to define the directory hierarchy, directory subdivision makes use of the new ${iterationvarsd} configuration variable. This variable is similar to ${iterationvarsf} but it contains slashes instead of commas, which makes it suitable for creating a directory tree. Enabling directory subdivision will cause /${configname}/${iterationvarsd} to be appended to the name of the results directory (see result-dir config option), causing result files to be created in a subdirectory tree under the results directory.
  • If you want to set up the directory hierarchy in a different way, you can do so by setting the result-dir config option and appending various variables to the value. E.g.: result-dir = "results/${repetition}"
  • Added the ${datetimef} inifile variable, which contains the current timestamp in a form usable as part of a file name.
  • Eventlog recording: Implemented snapshot and incremental index support to increase performance and scalability. This introduces significant (breaking) changes in the elog file format, and adds a set of associated configuration options; see the Sequence Chart section below for details.
  • Added %< (trim preceding whitespace) to the list of accepted directives
  • For log prefixes.
  • The obsolete command-line options -x, -X, -g, and -G were removed.
  • Made the -q option more permissive: if -c is missing, assume General
  • Added the -e option, which prints the value of the given configuration option.
  • Opp_run -v output now includes the system architecture OMNeT++ was built for
  • (e.g. ARCH_X86_64 or ARCH_AARCH64).
  • H resultfilters and -h resultrecorders now include the descriptions in the list of result filters and recorders.
  • Added two new -h topics: latexconfigvars, sqliteschema. They are mainly used for producing info for the Appendices in the manual.
  • In order to reduce OMNeT++'s external dependencies, we now use an embedded copy of Yxml as the default XML parser. Yxml (https://dev.yorhel.nl/yxml) is a small and fast SAX-style XML parser with a liberal license.
  • Support for using LibXML2 remained in place, but very few users will actually need it. Expat support has been removed. Note that no significant functionality is lost when Yxml is used instead of LibXML2. LibXML2 is only needed for Schema or DTD-based validation (and possibly, default value completion), which virtually no simulation models require. Also note that Yxml-based parsing scales much better than LibXML2, both performance-wise and regarding memory usage.
  • The bundled SQLite sources were upgraded to version 3.30.1.
  • Statistics recording:
  • Added the warmup filter. This filter discards values during the warm-up period, and is automatically inserted at the front of the result filter chains when the warmup-period config option is present.
  • Added the autoWarmupFilter statistic attribute that allows one to disable auto-adding the warmup filter to a statistic. Example:
  • @statisticfoo;
  • This will cause all values from the foo signal to be recorded, even values emitted during the warm-up period (if one is set).
  • However, the real motivation behind this feature is to allow the user to add the warm-up filter at a non-default location in the filter chain, because the default location is not always correct.
  • For example, @statistic[foo](source=min;record=vector) is equivalent to @statistic[foo](source=min(warmup(foo));autoWarmupFilter=false;record=vector), and records (as vector) the minimum of the values which were emitted after the warmup period is over. In contrast, if we replace min(warmup(foo)) with warmup(min(foo)), it will compute the minimum of ALL values, but only starts recording the result after the warmup period has expired.
  • This is a crucial difference sometimes. For example, a statistic might record queue length computed as the difference of the number of messages that entered the queue and those that left it:
  • @statisticqueueLen; //INCORRECT
  • In this case, if a warmup period is set, the result may even go negative because the pkIn and pkOut signals that arrive during the warmup period are ignored, and if pkOut arrives after that, we are at -1. The correct solution is to add the warmup filter after the difference between arrivals and departures have been computed:
  • @statisticqueueLen; //OK
  • The autoWarmupFilter option exists because either location for the warmup filter (beginning or end of the chain, or even mid-chain) may make sense for certain statistics. The model author needs to decide per-statistic which one is correct.
  • Added the demux filter, which allows splitting the stream of values arriving from a signal to multiple streams. For example, if values from a foo signal are tagged with the labels first, second and third, then the following statistics:
  • @statisticfoo;
  • Will produce three scalars: first:foo:count(demux), second:foo:count(demux), and third:foo:count(demux). The labels are taken from the (full) name of the details object specified in the emit() call.
  • This filter is especially useful if you intend to save multiple instances of the same statistics from the same module (e.g. per-connection TCP statistics).
  • In result files, the ,vector suffix is now suppressed in the titles of vector results (similarly also ,histogram and ,stats), as they simply echo the result item's type. (They were there in the first place because recording mode is automatically appended to result titles @statistic(title=...) after a comma; it is now suppressed for the mentioned recording modes.)
  • Added the merge filter which multiplexes several inputs onto a single output. It is available in the source= part of @statistic.
  • Result filters: The count and sum filters now record the initial zero value as well.
  • Result files now include two new result attributes for each item: recordingmode, which is the item in the @statistic(record=...) list that produced the given result item, and moduledisplaypath, the module/channel path that contains display names instead of the normal names where available.
  • SumPerDuration filter: fix computation when invoked during warmup period.
  • Cmdenv:
  • Added the cmdenv-fake-gui boolean configuration option, which enables "fake GUI" functionality during simulation. "Fake GUI" means that refreshDisplay() is periodically invoked during simulation, in order to mimic the behavior of a graphical user interface like Qtenv. It is useful for batch testing of simulation models that contain visualization. Several further configuration options exist for controlling the details: cmdenv-fake-gui-after-event-probability, cmdenv-fake-gui-before-event-probability, cmdenv-fake-gui-on-hold-numsteps, cmdenv-fake-gui-on-hold-probability, cmdenv-fake-gui-on-simtime-numsteps, cmdenv-fake-gui-on-simtime-probability, cmdenv-fake-gui-seed.
  • Qtenv:
  • Modernized look: Material-style SVG-based icons, HIDPI support, dark theme support.
  • New actions on the main toolbar: "Debug next event", "Debug on errors", "Show animation parameters". ("Load NED file" was removed from the toolbar as it was rarely needed, but it's still available from the menu.)
  • The default digit separator used in the main simulation time and event number displays was changed to space.
  • A lot of effort was made to refine packet animation, also with regard to the new "transmission updates" API. For example, the animation filter now affects deliveries as well, and transmissions on ideal channels are now shown as a full-length line. Transmission updates are drawn as "notches" on the message line.
  • Turned off animating method calls by default. The rationale is that method call animations usually expose low-level (C++ implementation level) details on the GUI, which are rarely of interest to a casual user.
  • Added the possibility to disable method call visualization locally (for that module type) via the context menu, even when the global switch in the Preferences dialog is turned on.
  • Added support for showing a submodule's display name under the icon instead of, or in addition to, the normal name. The format can be selected in the context menu.
  • The view mode (grouped/flat/inheritance/children) in the Object Inspector used to be tied to the type (class) of the object displayed in the inspector. Since that resulted in too much mode switching while the user navigated the object tree, and the switching logic was not easily discoverable by the user, we removed the feature of per-type remembering of view modes. The view mode now only changes when the user explicitly switches in on the UI.
  • In the Object Inspector, added the possibility to select display mode (Children/Grouped/Flat/Inheritance) per-node. If display mode override is specified for a node, it will affect the whole subtree. The display mode for the selected tree can be changed via hotkey (Ctrl+B) or via the context menu.
  • The "Set Sending Time as Reference" option was added to the messages view context menu. This option makes it possible to set a reference time, and display all other times as a delta compared to it.
  • In the messages view, there was a slight change in the notation used for the source and destination modules of the message, in order to make it unambiguous. Use explicit "." and "^" to indicate the location of the module. Also, it now uses arrows of uniform lengths everywhere.
  • The "Allow Backward Arrows for Hops" option was added to the messages view context menu. When this option is enabled, it allows the use of backward arrows to ensure a consistent relative ordering of modules in the log. For example, if two modules A and B exchange messages, this option will cause the window to display them as "A-->B" and "A<--B", as opposed to the default "A-->B" and "B-->A". This sometimes makes the log easier to follow.
  • Added support for new columns in the packet log view: TxUpdate, Durations, Length, Info. This was implemented in the cDefaultMessagePrinter class which is part of the simulation library. This change makes it possible to see if a packet is a transmission update (except if the simulation installs its own packet printer like INET does).
  • In the messages view, simulation time is now formatted with digit grouping on.
  • In the log, the banners of component init stages that do not print anything are now suppressed.
  • Added the "Fira Code" font as embedded resource, and set it to be used by default for the log window. The reason is that it provides nice "-->" arrow ligatures in the Messages view.
  • Prevent manually enabled "Debug on Errors" setting from being turned off by (lack of) configuration option.
  • Fix osgEarth viewpoints ignoring SRS (PR #851).
  • Countless small improvements and bug fixes.
  • Raised the minimum required Qt version to 5.9.
  • Tkenv:
  • Tkenv has been removed. Use Qtenv for all simulations.
  • Tools:
  • The names of all command-line tools now begin with opp_.
  • Added opp_ide, an alternative to the omnetpp command that launches the Simulation IDE.
  • Added opp_neddoc, a tool that makes it possible to generate HTML documentation from NED files from the command line. opp_neddoc works by launching the IDE in headless mode.
  • Opp_nedtool was rewritten for convenience and features. The main points are the following:
  • Removed msgc-related functionality, now it is really just about NED.
  • Command-line interface redesigned for better usability (subcommands, better help, etc.)
  • Added support for generating C++ source (cpp subcommand), for embedding NED files into an executable or library.
  • The tool now accepts directories as command-line arguments, too, and processes all NED files in them.
  • More convenient output (no *_n.ned, *_n.xml).
  • Removed obsolete @listfile and @@listfile support.
  • Fixed bugs in splitting NED files to one NED type per file.
  • Opp_msgtool was rewritten in the style of opp_nedtool. Details:
  • Made --msg6 the default mode, --msg4 was removed.
  • The command-line interface now uses subcommands; if no subcommand is specified, the default action is C++ code generation. The rarely useful -T (type of next file) and -h (here) optio

New in OMNeT++ 6.0 RC 2 (Mar 14, 2022)

  • OMNeT++ 6.0 is the result of more than three years of work, and includes many essential new features that we would already have a hard time without. The present changelog summarizes all changes made during the 15+ pre-releases.
  • We briefly summarize the changes below in each part of OMNeT++ before going into the details.
  • The most prominent new feature is the new Python-based Analysis Tool in the IDE. The use of Python under the hood allows for arbitrarily complex computations to be performed on the data, visualizing the result in the most appropriate form chosen from a multitude of plot types, and producing publication quality output, all while using an intuitive user interface that makes straightforward tasks easy and convenient. Custom computations and custom plots are also easily accessible. The tool is able to handle large quantities of data. The Python APIs are also available outside the IDE (e.g. for standalone scripts), and a command-line tool for viewing and exporting charts created in the IDE also exists (opp_charttool).
  • The NED language now supports parameters that carry C++ objects as values (type object), which can be used to parameterize modules with structured data (e.g. nontrivial configuration), packet prototypes, function objects, etc. Structured data may come from NED functions like readCSV() or readJSON() which parse data files, or may be specified directly in NED or ini files using JSON syntax. The syntax of ini files has even been adjusted to make it more convenient to write multi-line JSON values in it. Further new functionality includes the string match operator =~, the "spaceship" operator <=>, and support for Universal Function Call Syntax (UFCS). Incompatible changes include the change in the interpretation of parameter names that are not qualified with the this or parent keywords, and the necessity to mark module parameters with @mutable that are allowed to be set at runtime. Embedding NED files into simulation binaries for easier dissemination has also become possible.
  • Message descriptions (msg files) have undergone even bigger changes. An import system has been added to make the content of a msg file available in others. The generated code and class descriptors can now be widely customized via properties. Targeted C++ blocks have been introduced for injecting C++ code into various places in the generated source files. Altogether, these (and further, smaller) features facilitate writing significantly cleaner msg files, especially in large projects like INET.
  • The format of ini files have been made more flexible: the Config word in section headers is now optional, and long lines can be broken up to multiple lines without using trailing backslashes (just indent the continuation lines).
  • In the simulation kernel, the most important change is the introduction of the Transmission Updates API, which allows in-progress packet (frame) transmissions to be modified, i.e. aborted, shortened, or extended. This API is necessary for implementing L2 features like frame preemption or on-the-fly frame aggregation. Other changes include the addition of utility APIs like scheduleAfter(), rescheduleAt() and rescheduleAfter(), refinements around module deletion and the introduction of the preDelete() virtual member function, refinements in the signals and listeners APIs, improved expression evaluation support, and the addition of string-handling utility functions, just to name a few.
  • Regarding statistics recording, perhaps the most significant addition is the demux filter, which allows splitting a single stream (of emitted values) to multiple streams. The filter makes it possible to record statistics subdivided by some criteria, e.g. to record statistics per TCP connection, per remote IP address, per traffic class, etc., in INET. Further improvements include the addition of the warmup filter and the autoWarmupFilter statistic attribute that allow computed statistics to be calculated correctly also in the presence of a nonzero warm-up period. Result files now hold more metadata: parameter values and configuration entries are now also (optionally) recorded. This change, together with other, smaller adjustments, cause new result files not be understood by previous versions of OMNeT++.
  • A significant amount of work has been put into improving the looks and functionality of Qtenv: material-style icons, HIDPI support, dark theme support, and countless small features that improve usability, especially around the Object Inspector and the Log View. For example, it is now possible to set the Messages view of the Log to display all timestamps as a delta to a user-specified reference timestamp; or, the Object Inspector now allows selecting a different display mode for a tree node. One important change is that method call animations are now disabled by default.
  • The Sequence Chart tool in the IDE has been significantly improved, both visually and functionally, with the goal of allowing the user to configure the chart in a way that facilitates understanding of the sequence of events in the simulation. The tools provided for that purpose are the possibility to hide unnecessary elements (unrelated arrows, events, etc), support for user-defined coloring, interactively collapsible compound module axes, horizontally expanded events so that the arrows of nested method calls do not overlap, and more. The eventlog file format has also changed in a non-backward-compatible way, due to the addition of extra elements that allow the Sequence Chart tool to be faster and more scalable.
  • Generating documentation from NED and MSG files has been made possible from the command line as well, using the new opp_neddoc tool. Functionality has been extended with the possibility of incorporating external information into the generated pages.
  • The C++ debugging experience has been made more pleasant in several ways. For example, the "Debug on Error" and "Debug Next Event" functionality in Qtenv may now invoke the integrated debugger of the Simulation IDE, which is especially useful when the simulation was launched from the IDE. The User Guide also contains a hint on how to configure simulations to invoke VS Code as debugger.
  • Due to improvements in the toolchain and the build process, Windows users may see the linking time of large models like INET Framework to drop dramatically (1-2 orders magnitude, e.g. from several minutes to several seconds). On macOS, Apple Silicon, is currently supported with x86-64 emulation.

New in OMNeT++ 6.0 RC 1 (Feb 7, 2022)

  • Message compiler:
  • Changes in method names of the generated class. The drop method generated for owned pointer fields was renamed to remove; the single-argument insert method for arrays was changed to append.
  • Allow the namespace; syntax to make it possible to return to the toplevel C++ namespace.
  • Added the @abstract field and class property. For a field, it is equivalent to the abstract keyword; for classes it marks the whole class as abstract.
  • Abstract fields not to require the class to be marked with @customize.
  • Added the @customImpl field property. When specified, it suppresses generating implementations for the field's accessor methods, allowing custom implementations to be supplied by the user.
  • Introduced the @datamemberType property, and @cppType now serves as a default, for @datamemberType, @argType, and @returnType.
  • The generated class descriptors no longer use operator<< for converting field values to string in getFieldValueAsString(). Instead, @toString is used if the class has one, or the str() member if the type has one; otherwise the empty string is returned.
  • Many bug fixes and improvements.
  • C++ Debugging Support:
  • Allow "Debug on Error" and "Debug Next Event" functionality to use the integrated debugger of the Simulation IDE. This required multiple changes. First, the IDE was extended to accept an URL which, when opened in the IDE, causes the integrated debugger to start a debug session and attach to a process given with its PID. This URL is:
  • The URL can also opened from the command line, by running the omnetpp command with it as argument. The command opens the URL in the existing IDE instance if it is already running, or starts a new one if it does not.
  • The second change was to update the default value of the debugger-attach-command configuration option to use the above command. (Previously it has used various other debuggers which were likely to be found on the host OS: GDB, Nemiver, VS Code, etc.)
  • Analysis Tool:
  • Ask whether to keep temporary charts upon editor close, and only then.
  • Overhaul of the Bar Chart, Scatter Plot, and Box-and-Whiskers Plot chart templates.
  • Use an authentication token and explicit addresses for the Py4J connections between the IDE and Python processes, to improve security.
  • Added a version number to the omnetpp.scave.* Python modules.
  • Restore error marker functionality in the chart script editor, better error reporting from vector operations, and several further improvements and bug fixes.
  • Documentation Generator:
  • Changed the XML format in which extra content for the generated NED documentation can be provided.
  • Documentation:
  • Simulation Manual has been mostly updated for the current state. There are some remaining sections that need more work.
  • Tools:
  • Added a new command named opp_ide to start the IDE, and made omnetpp and omnest to be its aliases.
  • Opp_charttool: Added the templates command which lists the available chart templates.
  • Opp_run: Added new -h topics: latexconfigvars, sqliteschema. They are mainly used for producing info for the Appendices in the manual.

New in OMNeT++ 6.0 Preview 15 Pre-release (Jan 17, 2022)

  • This prerelease contains minor fixes and cleanups in preparation to the final 6.0 release.
  • Core:
  • Allow expressions in config option values to use NED operators, module parameters and other NED expression features. The immediate motivation was to be able use e.g. index in the display-name option, e.g.: **.app[0..3].display-name = "cbr-" + string(index)
  • The displayName field was moved from cModule to cComponent.
  • Result filters: The count and sum filter now record the initial zero value. This necessitated adding two methods to the cResultListener interface: added emitInitialValue() and callEmitInitialValue().
  • Result files now include two new result attributes for each item: recording mode (the item in the @statistic(record=...) list that produced the given result item), and module/channel display names (recordingmode, moduledisplaypath).
  • In result files, the ", vector" suffix is now suppressed from the titles of vector results (similarly also "histogram" and "stats"), as they simply echo the result item's type. (They were there in the first place because recording mode is automatically appended to result titles @statistic(title=...) after a comma; it is now suppressed for the mentioned recording modes.)
  • SumPerDurationFilter: fix getSumPerDuration() behavior when invoked during warmup period.
  • Analysis Tool:
  • Added the possibility to organize charts into a hierarchical folder structure. This can be very useful if the number of charts in the analysis exceeds a certain number. Charts can be moved between folders using copy/paste. Note that .anf files that contain folders are not understood by previous versions.
  • The "Reset Chart to Template" operation now allows multiple charts to be selected.
  • New chart template: "Line Chart on Separate Axes with Matplotlib".
  • New vector operation: timedilation (multiplies time with a constant).
  • Added a "Legend" page to the configuration dialogs of most chart templates. This page allows legend labels to be customized in several ways. Legend labels can now be specified manually, using a format string that may refer to dataframe columns as $name, $title, $module, etc. (content assist is available). For automatic legend labels, there is the option to use result titles (descriptive names) instead of result names, and module display name paths instead of plain module paths, where available. Finally, there is a possibility to perform a series of regular expression find/replace operations in the automatic or manual legend labels for fine tuning.
  • Note that since charts in .anf files contain copies of their chart templates and not references to them, charts in existing .anf files need to be reset to their templates in order to gain the new Legend page (see context menu in the Charts page).
  • Automatic legend labels, axis and plot titles are now generated with a better algorithm.
  • Inside chart templates, there was an effort to structure charts scripts so that they have the structure of distinct result query, data preparation and plotting steps, where all three steps are ideally just one or two lines of code. To this end, several functions were factored out from chart scripts into utils.py: plot_lines(), plot_boxwhiskers(), pivot_for_barchart(), pivot_for_scatterchart(), get_confidence_level(), etc. plot_bars() was extended to accept a metadata df (for legend label generation), and it now expect the data df in transposed form.
  • There were several improvements in the extract_label_columns(), make_legend_label() and make_chart_title() functions (utils.py), to support improved legend label, axis label and plot title generation.
  • A distinct exception class ChartScriptError was introduced for errors that are to be displayed in the plot area without dumping the stack trace to the console.
  • Numerous bug fixes and smaller improvements. A notable bug fix is that of a crash due to errors in managing shared memory buffers used for communication between the IDE and Python processes of chart scripts. Numerous errors were fixed in chart image export (i.e. the Matplotlib emulation of native plotting widgets) as well.
  • Inifile Editor:
  • Config option values that contain expressions are no longer falsely flagged as errors.
  • The confusing "Unused entry (does not match any parameters)" warning that often appeared falsely for INET simulations due to deficiencies in analyzing the network structure has been re-worded to include the possibility that it is false, and has also been demoted from "warning" to "info".
  • IDE:
  • Update to Eclipse 4.22, CDT 10.5 and PyDev 9.2. The private JRE bundled with the IDE has been updated to Java 17 LTS.
  • Sample simulations:
  • Fifo: Added a TandemQueues network, and related configurations into omnetpp.ini.
  • Resultfiles: Added the scalar and vector result files from the Fifo1 and Fifo2 simulations and the new TandemQueueExperiment.
  • Tools:
  • opp_charttool: Filtering options (-i, -n) were improved to allow multiple charts to be selected. The -i option now accept index lists and ranges too, not only single indices. The -n option was changed to use substring match instead of full match.
  • opp_charttool: Added the "templates" command which lists the available chart templates.
  • opp_test: The set of possible test outcomes has been refined. Possible outcomes are now PASS, FAIL, ERROR, SKIP and EXPECTEDFAIL. SKIP means that the test was not performed, because e.g. it would test an optional feature which is currently disabled; ERROR means that the test was not performed, because of an unrecoverable error (i.e. crash or exception). It is possible to designate a test case as an "expected failure", by specifying %expected-failure: Description of reason in the test file. This is useful if we know that a certain test-case is correct, but it is not possible to fix it for certain reasons.
  • opp_run -v now outputs the system architecture OMNeT++ was built for (e.g. ARCH_X86_64 or ARCH_AARCH64).
  • On Windows and macOS, the directory names in the tools directory have changed to win32.x86_64 and macos.x86_64 respectively.
  • Build:
  • The content of the $PLATFORM makefile variable has changed. Until know, it contained the platform.architecture pair (e.g. win32.x86_64) which was misleading. From now on, Makefile.inc provides $PLATFORM (e.g. win32) and $ARCH (e.g. x86_64) in separate variables. makefrag files must be updated if $PLATFORM variable was used in them.
  • To build OMNeT++ with Akaroa support, WITH_AKAROA=yes must be specified in the configure.user file. The configuration script no longer tries to autodetect Akaroa without the user explicitly requesting it.

New in OMNeT++ 5.7 (Jan 17, 2022)

  • This version is intended to be the last release of the 5.x series. The main purpose of this release is to make it possible to write model code, primarily NED, which is also compatible with the upcoming OMNeT++ 6.0. It also contains several bug fixes backported from the 6.0 branch.
  • For compatibility with 6.0:
  • NED: support for "parent.foo" syntax of parameter references (and other references too, see below) in expressions. Using the "parent" qualifier is only allowed inside submodule and connection blocks (within the curly braces), but not on compound module level. This change is necessary for being able to write NED files which are compatible with both OMNeT++ 5.7+ and 6.x. The interpretation of parameter references in expressions have changed in 6.0. In 6.0, a foo parameter reference in a submodule means the parameter of the same submodule (this.foo), while in 5.x it means the parameter of the enclosing compound module (which would be expressed in 6.0 as "parent.foo").
  • The way to write NED files compatible with both is to always explicitly qualify the parameter with this or parent. In a NED file written for 5.x, prefix plain parameter references inside subcomponent curly brace blocks with parent. to ensure that their meaning doesn't change in version 6.0.
  • The same change applies to submodule and gate references as well, e.g. in the argument of exists() and sizeof().
  • The change also affects the interpretation of references in expressions that occur in ini files.
  • MatchExpression: added field =~ pattern syntax as alternative to field(pattern)
  • Added Ws, Wh, kWh, MWh to the list of recognized measurement units
  • Core:
  • Statistic recording: Added a way to disable auto-adding of the warmup filter. One needs to specify autoWarmupFilter=false in the @statistic for that. This opens the possibility for the user to add warmup filters to a custom place, not just before all other filters. E.g. consider min(warmup(foo)) (which is produced by auto-adding of the warmup filter), and warmup(min(foo)) which might be what the user wants instead.
  • Fingerprints: Fixed a bug in cHasher::add(const char *) which caused some bits in the input not affect the fingerprint. This bugfix does not affect the fingerprint of most simulations, because very few fingerprints use strings as input.
  • Canvas: In cPathFigure, path parsing was refined: If an op char is missing, assume previous one, in accordance with the SVG specification.
  • cHistogram and histogram strategy classes: work around several problems caused by the finite precision of 'double'.
  • Miscellaneous other bug fixes.
  • Cmdenv:
  • Added Fake GUI mode. Fake GUI means that refreshDisplay() is called periodically during simulation, in order to mimic the behavior of a graphical user interface like Qtenv. It is useful for testing simulation models with visualization using Cmdenv, e.g. in smoke or fingerprint tests. Fake GUI can be enabled with the cmdenv-fake-gui=true configuration option.
  • The set of currently supported options for Fake GUI: cmdenv-fake-gui-before-event-probability, cmdenv-fake-gui-after-event-probability, cmdenv-fake-gui-on-hold-probability, cmdenv-fake-gui-on-hold-numsteps, cmdenv-fake-gui-on-simtime-probability, cmdenv-fake-gui-on-simtime-numsteps, cmdenv-fake-gui-seed.
  • Qtenv:
  • Added Ctrl+W as shortcut for closing toplevel inspector windows.
  • Made the "Run" and "Fast" buttons "pop out" (and stop simulation) if triggered again. This adds a radiobutton-like behavior to these actions, which is handy for running the simulation for a very short time, with a single button.
  • Log Inspector: Perform "find" on plain text comment, i.e. ignore formatting escape sequences.
  • Log Inspector: After a search, scroll the found text into the middle of the viewport instead of just to the edge.
  • Find dialog: Select the entire searched text when opening the find dialog, to allow easier and quicker typing of a different query.
  • Further bug fixes.
  • Tools:
  • JsonExporter: Fix: In the exported file, result items appeared under multiple runs due to missing filtering. Applies to both the IDE and opp_scavetool.
  • In the Simulation Manual, the section about opp_scavetool was out of date.
  • Simulation IDE:
  • Welcome screen theme changed (circle -> solstice) due to problems with dark theme with the old 'circle' theme.
  • The Download Simulation Models dialog now supports specifying a custom project name and location. Also, the default project name is now coming from the downloaded descriptor file (not from the .project file in the archive.)
  • Fixed the download issues in the Download Simulation Models dialog.
  • NED, Ini Editor: Syntax highlight for the NED parent keyword
  • Ini Editor: group fingerprint and fakegui-related fields on a separate new form page.
  • NED Editor: Fix rendering issue with the mouse cursor for the creation tool in the palette.
  • Launcher: Print working directory and command line to console when debugging simulations, similar to the simple "run" mode launch.
  • Launcher: On macOS, use lldbmi2 for debug launches by default.
  • Makefile generation brought in sync with omnetpp-6pre11.
  • Build:
  • Use Eclipse 4.21, and JustJ as the private JRE.
  • Use python3 as the interpreter for Python scripts.
  • opp_makemake: Makefile generation brought in sync with omnetpp-6pre11.
  • Got rid of a few bison warnings and properly test for Bison 3.
  • Fixes for the Windows build.
  • Updated bundled sqlite3 amalgamation sources.

New in OMNeT++ 5.4.1 (Jun 29, 2018)

  • This release contains last-minute features and improvements, mostly motivated by the upcoming INET 4 release. Highlights are the typename and exists() operators in NED; nan and inf keywords in NED; support for logarithmic units like dB, dBW, dBm, dBV, dBmV. Qtenv has also gained much more powerful just-in-time debugging capabilities than before.
  • NED:
  • Allow 'typename' in expressions. Motivation: we want to be able to write:
  • foo: <> like IFoo if typename!=""
  • Added the "exists" operator. Syntax: exists(<submodulename>)
  • Introduced "nan" and "inf" as keywords for numeric constants
  • Core:
  • SimTime now has a new method named ustr() that prints the time in an appropriate unit. It is now used in cClassDescriptor for displaying simtime_t fields and at a few other places.
  • SimTime: more precise computation for integer-SimTime division.
  • Measurement units are now available as NED functions as well. They accept dimensionless numbers and quantities with a compatible unit. E.g. the expressions mW(2*100) and mW(0.2W) both result in 200mW.
  • New measurement units: K, Ohm, mOhm, kOhm, MOhm, uW, nW, pW, fW, THz, kmps, binary and decimal multiples of bit (Kib, Mib, Gib, Tib, kb, Mb); deg, rad; pct (percent), ratio.
  • Support for logarithmic units: dBW, dBm, dBV, dBmV, dBA, dBmA, dB. Conversion between logarithmic and corresponding linear units (W vs. dBW) is supported. Conversion between bit and byte (and multiples) is also supported.
  • cPacket: refined str() method
  • Several smaller improvements.
  • Qtenv:
  • Debug-on-error functionality can now be turned on interactively, via the Simulate -> Debug on Errors menu item.
  • When an error occurs and debug-on-error is enabled, Qtenv now offers to launch and attach an external debugger unless the simulation program is already being debugged. The same applies to the Debug Next Event functionality. External debuggers can be configured with the debugger-attach-command configuration key, and can also be overridden with the OMNETPP_DEBUGGER_COMMAND environment variable.
  • Workaround for a crash with Qt 5.11.
  • IDE:
  • Launcher: fix: The IDE sometimes started build in the UI thread, locking up the UI for the time of the build, potentially for several minutes.
  • Fixed "unknown" image as module background in the graphical NED editor.
  • Fix: do not report "undefined parameter" for typename assignments in NED
  • Fix: inifile analysis: typename deep assignments in NED were ignored

New in OMNeT++ 5.4 Preview (Jun 13, 2018)

  • NED:
  • Allow 'typename' in expressions. Motivation: we want to be able to write:
  • foo: <> like IFoo if typename!=""
  • Added the "exists" operator. Syntax: exists(<submodulename>)
  • Introduced "nan" and "inf" as keywords for numeric constants
  • Core:
  • SimTime now has a new method named ustr() that prints the time in an appropriate unit. It is now used in cClassDescriptor for displaying simtime_t fields and at a few other places.
  • SimTime: more precise computation for integer-SimTime division.
  • Measurement units are now available as NED functions as well. They accept dimensionless numbers and quantities with a compatible unit. E.g. the expressions mW(2*100) and mW(0.2W) both result in 200mW.
  • New measurement units: K, Ohm, mOhm, kOhm, MOhm, uW, nW, pW, fW, THz, kmps, binary and decimal multiples of bit (Kib, Mib, Gib, Tib, kb, Mb); deg, rad; pct (percent), ratio.
  • Support for logarithmic units: dBW, dBm, dBV, dBmV, dBA, dBmA, dB. Conversion between logarithmic and corresponding linear units (W vs. dBW) is supported. Conversion between bit and byte (and multiples) is also supported.
  • cPacket: refined str() method
  • Several smaller improvements.
  • Qtenv:
  • Debug-on-error functionality can now be turned on interactively, via the Simulate -> Debug on Errors menu item.
  • When an error occurs and debug-on-error is enabled, Qtenv now offers to launch and attach an external debugger unless the simulation program is already being debugged. The same applies to the Debug Next Event functionality. External debuggers can be configured with the debugger-attach-command configuration key, and can also be overridden with the OMNETPP_DEBUGGER_COMMAND environment variable.
  • Workaround for a crash with Qt 5.11.
  • IDE:
  • Launcher: fix: The IDE sometimes started build in the UI thread, locking up the UI for the time of the build, potentially for several minutes.
  • Fixed "unknown" image as module background in the graphical NED editor.
  • Fix: do not report "undefined parameter" for typename assignments in NED
  • Fix: inifile analysis: typename deep assignments in NED were ignored

New in OMNeT++ 5.3 Preview 4 (Apr 3, 2018)

  • Core:
  • cMessagePrinter: API was extended with tags and column names
  • cCanvas: added getAnimationSpeed(); better documentation for setAnimationSpeed() and holdSimulationFor().
  • cHistogram, cNedValue: minor changes in the public API
  • Result recorders: Added "timeWeightedHistogram" recorder
  • Made statistic recorders "findable" from Qtenv
  • Qtenv:
  • Implemented support for the improved cMessagePrinter Options API, and added a respective configuration dialog.
  • The log viewer now supports ANSI control sequences for text styling: foreground/background color, and bold/italic/underline text. Styling is supported in both message history view and log view, i.e. it can be used in text returned from cMessagePrinter and logged by the EV and other logging macros.
  • Rewritten the controller for smooth animation. The new algorithm is now able to scale linearly, as long as the simulation can keep up.
  • Usability improvements in the Animation Parameters dialog, e.g. it now also displays the current simulation speed, and it is colored red if the simulation cannot keep up with the requested animation speed.
  • Histogram inspector: visualize outlier bins (drawn with a different color than normal bins), and show info about them. Fix numeric overflow when large numbers (>= 2^64) are shown.
  • Toolchain and dependencies:
  • Updated toolchain on Windows (clang 5.0.1, gcc 7.3, gdb 8, osgEarth 2.7)
  • Updated toolchain on macOS (OpenSceneGraph 3.2.3, osgEarth 2.7)
  • OMNeT++ now requires osgEarth 2.7 or later (check the Install Guide for further instructions on how to upgrade osgEarth.)
  • Tools:
  • - opp_runall, opp_fingerprinttest, opp_test: portability fixes for Windows and macOS
  • - opp_fingerprinttest: fix: error messages from the simulation did not appear
  • Samples:
  • canvas: Added smooth animation with CarAnimator::refreshDisplay().
  • osg-earth, osg-satellites: Switch from ObjectLocator to GeoTransform. The former was removed after osgEarth 2.8, and the latter has been around for quite some time now.
  • Documentation:
  • Documented smooth animation in detail, and updated the section on statistical data collection classes (cStdDev, cHistogram) in the Simulation Manual.

New in OMNeT++ 5.2.1 (Apr 3, 2018)

  • Minor bug fixes and improvements in Qtenv.
  • Other minor bug fixes.
  • Updates to the C++ Development and Launcher chapters of the User Guide.

New in OMNeT++ 4.6 (Dec 3, 2014)

  • Tkenv:
  • Improved zooming/panning support: use double click to zoom in around a point, and Shift + double click to zoom out; use Ctrl + left mouse button to drag out a rectangle to zoom to (a.k.a. marquee zoom; implementation based on patch from Christoph Sommer), right-click cancels marquee zoom; use left mouse button for panning
  • Core:
  • The testing tool opp_test has been revised and is now an official part of OMNeT++.
  • The Manual now has a new chapter that covers the testing of simulation models as well as the usage of the opp_test tool.
  • The message compiler opp_msgc was reimplemented as a part of nedtool. opp_msgc still exists as a wrapper script that points to nedtool.
  • IDE:
  • The IDE is now based on Eclipse 4.4 Luna, and requires JDK 1.7 or later.
  • The IDE is now a 64-bit application on Mac OS X.
  • Other:
  • OMNeT++ is now using C++11 by default (-std=c++11) when models are compiled. The simulator itself does not use any of the C++11 features, so C++11 support may be disabled in configure.user. Update your models to compile properly using the C++11 standard, as later OMNeT++ versions will require C++11 compliance.
  • OMNeT++ can be configured to use the 'omnetpp' namespace by setting USE_NAMESPACE=yes in configure.user
  • Clang compiler support: Clang is used by default on OS X, and can be turned on on Linux. Clang is still not supported on Windows (we are waiting for the MSYS Clang packages to mature).
  • The bundled MSYS/MinGW toolchain was updated to use MSYS2. MSYS2 resolves a number of issues:
  • No more memory errors during build
  • The make command now properly supports parallel build (-j4, -j8 etc.)
  • The bundled MSYS2 toolchain now contains the pacman package manager, so you can install additional packages if you wish
  • Change in OMNeT++: The msys/ directory has been moved to tools/win32/ while the mingw/ directory that contains the compiler has been moved to tools/win32/mingw32/.

New in OMNeT++ 4.5 (Jul 17, 2014)

  • The focus of version 4.5 was to improve the usability of the Graphical Runtime Environment (Tkenv). The Tkenv GUI has been redesigned for single-window mode to improve usability and user experience. Tkenv has also received a new, modern look and feel, due to the use of the Ttk widgets and a custom Ttk theme.
  • single-window mode, with object navigator + 3 built-in inspectors that interact in a meaningful way (new inspector windows can still be opened)
  • keep inpector windows on top of the main window at all times
  • use Ttk widgets everywhere, with custom theme - this makes a huge difference in looks on all platforms but esp. on OS X
  • BLT no longer needed (we use Ttk instead)
  • inspectors are no longer tied to a single object; visited objects are remembered as navigable history (back/forward)
  • module graphics now remembers zoom level and settings per NED type
  • for each log line, the context module is now stored, and is shown as a line prefix where it makes sense (differs from event’s module)
  • Tkenv now stores message sendings and also a clone of corresponding message objects (cMessage), and can show them in the log window
  • message printer classes can be contributed to customize the messages view of log windows
  • more concise status area that shows more information at the same time
  • part of the status area can be turned off to free up vertical space
  • timeline drawing now adapts to font size
  • on-demand scrollbars (i.e. they are hidden when not needed)
  • main menu cleanup (reorganized, removed obsolete items)
  • dialogs where it makes sense now remember size and location
  • additional hotkeys: Ctrl+Plus/Minus for Zoom, Ctrl+F5 Run Until, Ctrl+Q Quit, etc.
  • OS X: use Command key for hotkeys instead of Ctrl
  • countless other, smaller improvements
  • In the Windows bundle, the debugger have been upgraded to gdb-7.7; Tcl/Tk has been upgraded to version 8.6.0.
  • New configure.user option to prefer clang over gcc if both are installed
  • New configure.user option to enable/disable C++ 11 compilance (-std=c++11) Note that this is NOT supported on Windows because of issues with the bundled MinGW 4.7 compiler.
  • Tcl/Tk version 8.5 is required, 8.6 is preferred; BLT is no longer in use

New in OMNeT++ 4.4.1 (Mar 28, 2014)

  • Sim:
  • Support for optional signal checking. When signal checking is turned on, signals emitted by modules/channels must be declared with a @signal property in the module’s or channel’s NED description; undeclared signals will result in a runtime error. Signal declarations are of the form
  • @signal[](type=);
  • may contain wildcards (?,*). Type is optional; if present, data type can be long, unsigned long, double, simtime_t, string, or a registered class name. To allow NULL pointers, append a question mark to the class name. Example:
  • @signal[receivedPk](type=cPacket?);
  • This feature is controlled by the check-signals= configuration option, and it is turned off by default for now.
  • Support for @statistic-style declarative result recording on dynamically registered signals (e.g. "conn-" where n is an integer). Instead of @statistic, add a @statisticTemplate property in the NED file, and for each new signal call ev.addResultRecorders(...).
  • Support for programmatically adding result filters and recorders on signals: cResultRecorder has been revised to allow result recorders to be used without a corresponding @statistic attribute, e.g. they can now be added to signals programmatically.
  • Further signals-related changes:
  • added emit(simsignal_t, const cObject*) to cComponent
  • added receiveSignal() overload for bool to cIListener
  • introduced SimsignalType which replaces the older cITimestampedValue::Type
  • added cObjectFactory::isInstance() method that effectively wraps a dynamic_cast
  • added Register_Abstract_Class() macro that allows abstract classes to be used in signal declarations as type.
  • Added cNEDValue::parseQuantity()
  • New result filter: removeRepeats
  • Feature: Just-in-time debugging support.
  • new configuration options: debugger-attach-on-startup, debugger-attach-on-error, debugger-attach-command, debugger-attach-wait-time.
  • the simulation kernel can invoke the debugger on an error (or on startup) using the command-line specified by the debugger-attach-command option.
  • NED:
  • More freedom in NED property syntax: (1) Hyphens, dots and colons are now allowed in property names and indices; and (2) values no longer need to be enclosed in quotes if they contain parens, provided that parens are balanced.
  • Tkenv:
  • Feature: Animation filters (right-click on any message, and select "Exclude messages like … from animation" from the context menu.)
  • Feature: "Debug Next Event" (Ctrl+F9). It causes the simulation program to stop in the debugger just before entering the handleMessage() call.
  • Fixes and workarounds for various issues on Mac OS X (poor animation speed, missing icons on OS X Mavericks, hang on the F5 key, etc.)
  • Fix: the "Filter Window Contents" dialog could lose state
  • Source cleanup (consistent naming style for Tcl procedures)
  • IDE:
  • Use Eclipse 4.3 as base platform
  • Support for project-specific images: icons from the "images/" folder of the project and its dependencies are automatically used by the NED editor, and added to the Tkenv image path when the simulation is launched. (The folder name is currently hardcoded; it will become configurable in future versions.)
  • Sequence Chart: Fixed bug that caused including the same reuses multiple times. Fixed error handling when the error occurs in paint during startup.
  • Improved support for C++11, Mac OS X:
  • The source now compiles without any warning with both gcc and clang, using the "-std=c++11 -Wall" flags (clang is the default compiler on OS X since version 10.9 Mavericks).
  • Added proper support for cross-compilation using ./configure --host=i686-w64-mingw32
  • Updated install instructions for OS X 10.9 Mavericks. Specifically, gdb is no longer distributed with OS X; users are expected to install it themselves from MacPorts, and digitally sign it.
  • IDE: fixed the launcher not to throw error if the toolchain is clang.
  • Updated the source to compile with both Bison 2.3 and 3.0

New in OMNeT++ 4.3.1 (Sep 24, 2013)

  • When the IDE is started with an empty workspace (e.g. on first-time launch), it offers the user the following options: (1) Import the OMNeT++ sample simulations into the workspace; and (2) Download and install the INET Framework.
  • The latter function is also available via the Help > Install Simulation Models... menu item. The menu item brings up a dialog with the list of simulation models available for automated installation, and lets the user choose. Currently only the INET Framework is listed there, but it is planned to add further models.
  • When the IDE is started for the first time, it now displays some helpful introductory pages in the editor area: "Getting Started" (practical advice for getting past the first 10 minutes spent in the IDE); "At a Glance" (explains the common file types like NED, msg and ini, and their purposes); "OMNeT++ Samples" (describes each example simulation in two sentences, then provides links for opening the project, viewing the README, launching the simulation, etc.) These pages are also available from the Help system (except the last one, which has a dedicated menu item under the Help menu.)
  • IDE launcher script: fixed #670 (vmargs conflict between omnetpp.ini and the launcher script). This bug could cause IDE crashes by PermGenSpace exhaustion.
  • Analysis Tool, Output Vector View: show "Go to" actions in the context menu (instead of the view's pulldown menu)
  • Analysis Tool: fixed #389 (Useless items in the Statistic Name filter): The filter hints of combos is now computed from the result items filtered by the other 2 combos.
  • Analysis Tool: fixed #388 (add '*.host[*].*' variant to module filter hints)
  • Ability to import sample projects even if workspace is different from omnetpp/samples
  • Trying to launch a closed project will now offer opening it
  • NED documentation generator: fixed #672 (Illegal group reference error)
  • Changed default appearance of the main welcome page to be more user friendly
  • Some other bug fixes

New in OMNeT++ 4.3 (Aug 15, 2013)

  • IDE:
  • Analysis tool: added support for computed scalars. Read the updated the User Guide for further details.
  • Analysis tool: added Logarithmic X axis option to scatter chart.
  • Added NED editor support for named channels.
  • Added support for opening files from the command line, i.e. use: $ omnetpp Aloha.ned
  • Added full screen mode (Ctrl-Shift-F11).
  • Usability improvements in the Analysis Tool.
  • Better error reporting in the Sequence Chart and Event Log views.
  • The CDT C++ code analyzer has been turned off as it was reporting too many false positives.
  • The IDE has been switched over to use CDT’s DSF debugger instead of the older CDI.
  • The IDE no longer runs the C/C++ Indexer before build (the code now collects the information for makefile dependency generation by other means)
  • Added pretty printing of STL containers (std::map, etc), simtime_t and other objects to the debugger; see the updated User Guide for details.
  • Updated the bundled MinGW (GCC, linker and GDB).
  • Updated to Eclipse 3.8.1; the IDE now requires Java 1.6+.
  • NED:
  • Added named channels support, e.g. "…←→ eth1: EthernetChannel ←→…", with the purpose of making it easier to address channel objects when assigning parameters from ini files. Channel definitions can now specify a default name (via the @defaultname property), too.
  • Sim:
  • Added the cPatternMatcher and cMatchExpression utility classes to the API. cPatternMatcher is a glob-style pattern matching class. cMatchExpression builds on top of cPatternMatcher and lets you combine patterns with AND, OR, NOT for matching fields of arbitrary objects.
  • Added hasEncapsulatedPacket() to cPacket.
  • Implemented calculateWeightedSingleShortestPathsTo() in cTopology.
  • Signals implementation now allows static initialization of simsignal_t variables.
  • Fixed a bug in Expression where -2m was evaluated to 2 (meter was lost)
  • Tools:
  • Simplified makefile output: Makefiles now output only the filenames to the console instead of whole commands. This makes the build output less noisy. If you need the old behavior, use the V=1 (verbose on) option on the make command line.

New in OMNeT++ 4.2.1 (Jan 24, 2012)

  • Several bug fixes.

New in OMNeT++ 4.2 (Jan 24, 2012)

  • Several bug fixes.

New in OMNeT++ 4.2 RC 2 (Jan 24, 2012)

  • Documentation:
  • Revised and significantly expanded the "C++ Development" chapter in the User Guide to better assist model developers; smaller improvements in other chapters
  • Tools:
  • Updated MSYS and MinGW binaries in the Windows distribution.
  • The build system now creates 64-bit binaries on Mac OS X 10.6 and 10.7 (if your processor supports it). Previously the -m32 flag was added to the GCC command line to force the creation of 32-bit binaries. (This was necessary because earlier versions of CDT did not support 64-bit debugging).
  • Enabled pretty-printing of variables in gdb (see below)
  • IDE:
  • Better C++ debugging experience: std::string, std::vector, std::map and other standard classes as well as simtime_t are now displayed in a meaningful way; simulation objects (cObject) display their full paths. This functionality is enabled by gdb pretty printer extensions written in Python, and is thus available for command-line gdb debugging too. For activating the pretty printers, see misc/gdb/README.
  • NED documentation generator improvements: better-looking tables in the generated documentation; running Doxygen is now cancellable; etc.
  • Dropped PowerPC support for the IDE because Mac OS X 10.7 no longer supports this architecture.
  • Sim:
  • Refactored operator= and copy constructor in all classes. Now they delegate to the same function in the super class, and the common part of the two is factored out to private copy() functions.
  • Fixed all warnings to make it compile using -Wall -Werror.
  • Coroutines used for 'activities' are now implemented using the swapcontext() POSIX call (if it is available on the system).
  • Sample simulations:
  • Database example revived. It demonstrates using database as configuration source, as storage for output scalars and vectors, and as source of network topology. Currently it works with MySQL.
  • Countless bug fixes and smaller improvements.

New in OMNeT++ 4.2 RC 1 (Jan 24, 2012)

  • Ini files:
  • Ini files: iterations (${…}) can now refer to other iteration variables, improvement makes it possible to have loops where the inner iteration range depends on the outer one. When needed, the default top-down nesting order of iteration loops is modified (loops are reordered) to ensure that expressions only refer to more outer loop variables, but not to inner ones. When this is not possible, an error is generated with the "circular dependency" message. Variables are substituted textually, and the text resulting from substitution is NOT evaluated except in the '.. step ' syntax, and in the 'constraint=' ini file option. CAUTION: textual substitution means that variables in arithmetic expressions should be protected with parentheses. The text substitution model was chosen for greater flexibility as well as the ability to produce a more consistent semantics. See src/envir/ChangeLog for more details.
  • Incompatible change: In the constraint= configuration option, variables now be surrounded with parens (to ensure precedence after the textual variable substitution). For example, the expression x+y GiB, TB -> TiB. The latter changes affect backwards compatibility, i.e. you may need to update existing models.
  • Tools:
  • opp_run: bugfix: release-mode simulation models compiled as shared libraries could not be run using a debug-mode opp_run program (they either crashed or reported that a module was not registered with the Register_Module() macro.) As part of the fix, a new opp_run_release program has been introduced, and opp_run (which is now always compiled as debug) delegates to it when necessary. Due to makefile changes related to the fix, you may need to re-create the makefiles of your simulation when upgrading to OMNeT++ 4.2. (You only need to do that when working on the command line. The IDE automatically recreates the makefiles, so no action is needed on your part if you are using only the IDE.) See src/envir/ChangeLog for details of this change.
  • Implemented number filter expressions using multiple inputs for statistics source expressions. For example:
  • @statistic[dropRate](source="count(packetDropped)/count(packetSent)");
  • opp_msgc: improvement: announcements and type definitions now observe whether they are above the namespace declaration (=outside the namespace) or below it (=inside the namespace). This change makes it consistent with cplusplus blocks that had this behavior for quite some time. A related improvement is that type lookup in namespaces has been modified to make it possible to use unqualified names when declaring fields. See src/nedxml/ChangeLog for details.
  • Akaroa support improved; samples/aloha/akaroa.ini was added as example
  • Documentation:
  • Several chapters in the User Manual have been updated; especially, the Message Definitions section was turned into a separate chapter, and was completely revised.
  • IDE:
  • Upgraded to Eclipse 3.7
  • Added Eclipse Marketplace to the Help menu. You can now install additional features from the market.
  • Before running the simulations, the IDE will show the command line in the console view to help you execute the same simulation from the command line.
  • Ctrl-Tab now works on freshly opened NED files even if you do not explicitly select a simple module. In that case, the IDE opens the .h and .cc files associated with the first simple module in the NED file.
  • Improvement on the Manage Build Configurations dialog: newly created build configurations are now configured, by copying the source entries from one of the existing build configurations.
  • Project Makemake Options property page: overhaul for better usability.
  • Documentation generator: turn on JAVADOC_AUTOBRIEF in newly generated doxy.cfg files. (When this option is on, there is no need for @brief in C++ doxy comments; instead the first sentence of the comment is taken automatically as brief description.)
  • Bug fixes on: IDE makefile generator; the Project Features feature; the Inifile Editor (hover info, content assist, etc); the NED editor (display string proposals for connections and channels, etc.); Organize Imports feature; NED documentation generator; Simulation Launcher (e.g. launching folders with simulations in them works again);
  • SVN support removed from the IDE. It had very few users, and can be installed from the Market if needed.
  • Removed Animation Player as it was only a "technology preview" bundled with the beta releases to gather feedback from the user community. The animator is scheduled to appear in the next major OMNeT++ release.

New in OMNeT++ 4.2 Beta 2 (Jan 24, 2012)

  • NED:
  • Added support for conditional submodules. Syntax:
  • udp: UDP if needsUDP {...}
  • tcp: like ITCP if needsTCP {...}
  • Added the xml() NED function, which accepts a string argument and parses it as XML. Its most notable use is eliminating "empty.xml" files from INET: one can use xml("") in NED files instead.
  • Implemented default value for parametric submodule and channel types. NED now supports the following syntax:
  • mobility: like IMobility;
  • The effect is that the NullMobility NED type will be used for the mobility submodule if the type name is not specified otherwise, e.g. in the config- uration with something like
  • .mobility.type-name = "ConstSpeedMobility"
  • Added the firstAvailable() NED function, which is helpful with the Project Features feature (see below). It accepts any number of strings (see new varargs support for NED functions), interprets them as NED type names (either short names or fully qualified names), and returns the first one that exists and is also "available" (its C++ implementation class exists). Example usage:
  • tcp: {..}
  • It chooses the TCP_lwIP, TCP_NSC or TCP module type for the tcp submodule, in this order, unless the type is explicitly defined to be something else in the configuration.
  • Parametric submodule type can now also be specified in NED files, using patterns that end in the new "typename" keyword. An example:
  • network Net {
  • parameters:
  • host[*].tcp.typename = "TCP_lwIP";
  • ...
  • Ini files:
  • The "type-name" per-object configuration option (**.typename=) has been renamed in to "typename", for consistency with the similar new NED feature.
  • Sim:
  • Implemented varargs support for NED functions. If the signature (see Define_NED_Function() and Define_NED_Function2() macros) ends in ", …", then the function will accept any number of additional arguments of any type. At runtime, the implementation has access to both the actual number and types of args. When passing extra args, optional arguments (those marked with '?' in the signature) must all be present, i.e. varargs can only come when all typed args are there.
  • IDE:
  • Upgraded to Eclipse 3.6.2
  • Implemented the "Project Features" feature, which makes it possible to disable unused parts ("features") of a project to reduce compilation time and complexity. It has been invented to help INET Framework users and developers deal with the growing size of the framework. Features are described in the project’s .oppfeatures file, authored by INET developers. Users can activate/deactivate features in the Project Features page of the Project Properties dialog (this page is directly accessible from the Project menu and from the Build Configurations submenu of the project’s context menu in Project Explorer). Features map to NED packages and C++ source folders; disabling a feature maps to NED package exclusion, and folder exclusion in CDT (C++ Development) configuration. Features can also define C/C++ symbols (for #ifdefs), and extra libraries to link with. At build time, the IDE checks the project’s configuration (NED, CDT) and if it is inconsistent with the selected features, it offers fixing it. Features can also be used from the command line by exporting Makefiles (or opp_makemake commands) that reflect a particular enablement of features.
  • Support for excluding (disabling) NED packages. This feature is needed for the Project Features feature. Exclusions can be edited on the NED Source Folders project property page, and are saved into the project’s .nedfolders file.
  • IDE/Animation Player:
  • Implemented lazy loading of the eventlog file: the tool can now animate large eventlog files with acceptable performance.
  • Animation effects refined, e.g. packet transmission on a datarate channel.
  • Heavy bugfixing. Note that the tool is still being actively developed, and it is generally not yet ready for everyday use.
  • IDE/Inifile Editor:
  • Usability: the editor now comes up with the page (text or form) that was used last time, and not always with the form editor. (When you flip the editor to the other page, the page type is stored in the preferences. When an editor is opened, the setting is read from the preferences and the corresponding page is activated.)
  • Improved text hover (F2) and hyperlink (Ctrl+click) support: the editor can now show information and go to the definition of modules that occur in the inifile key. For example, for a **.host[*].tcp.sackSupport = true line, the user can hover over (or Ctrl+click) the host[*] part, and the editor will show relevant information and go to the definition of the host[] submodule vector in the NED network description.
  • Improved content assist: per-object configuration options are now filtered by the type of object that the key refers to; for example, if you type **.ppp[*].txPkBytes., the editor will know from the NED files that txPkBytes is a statistic, and offer completions accordingly.
  • Content assist: different types of completions (modules, parameters, statistics, configuration options, etc) are now marked with icons.
  • Markers on included inifiles are now removed when the main inifile is closed. (Fix for #176)
  • Added the Copy action to the Module Parameters view context menu: you can now select the key for an unassigned parameter in the view, and copy/paste it into the editor area.
  • IDE/Wizards:
  • New Tictoc Example and New Source-Sink Example wizards: fix: the root Makefile executed opp_makemake in the src/ folder at each build, overwriting the IDE-generated Makefile.
  • New OMNeT++ Project wizard template: now it is possible to set "custom make" for a folder: specify :CUSTOM in the makemakeOptions= template variable in template.properties. Use "." to name the project root folder. Example: makemakeOptions = .: CUSTOM, src: --deep -meta:recurse…
  • New option for template.properties: preRunTemplate=. Example: preRunTemplate = main.fti. The option causes the given template file to be evaluated for its side effects, just after the user hits Finish but before any file is copied or template is evaluated. It is not allowed to produce text output, but the variables it sets will be substituted into other template.properties variables, and will also be available in other template files. (Note: all other templates are run in isolation, and cannot change variables for other templates!) The preRunTemplate option is the only way to programmatically set the value of makemakeOptions and similar template.properties options.
  • IDE/Graphical Editor:
  • Switched back double-click behaviour to Open NED Type action. The Properties dialog can now opened with Ctrl+Enter (Alt+Enter was unavailable.)
  • IDE/Sequence Chart and Event Log:
  • Added show/hide options for arrows that represent mixed dependencies. (Such arrows are drawn when the sequence chart is filtered, and represent e.g. a sequence of message sendings and self-messages)
  • Eventlog: enhanced performance of event tracing filter
  • Simulations now record the termination message and result code into the eventlog file
  • Note: eventlog file format has changed (in order to better serve the Animation Tool)?—?.elog files recorded with any prior version of OMNeT++ have to be re-recorded.

New in OMNeT++ 4.2 Beta 1 (Jan 24, 2012)

  • Simulation runtime:
  • Removed #include from ; the reason is that it conflicted with lwIP code recently integrated into INET. still includes , but now (and ) MUST precede in all source files.
  • Ini files: implemented multiple inheritance for sections. Syntax:
  • [Config Foobar]
  • extends = Foo, Bar
  • When the runtime looks for a config option or param assignment, sections are examined in a "fallback order" until the first match is found. In the above example the order would be: Foobar, Foo, Bar, General. OMNeT++ uses C3 lineratization to compute the section fallback order, see e.g. http://en.wikipedia.org/wiki/C3_linearization
  • Ini files: better parsing for iteration variables, e.g. the value in $uniform(1,2) is now parsed as one item, not as "uniform(1" and "2)". Nested parens/brackets/braces and string literals are recognized; escaping commas and close-braces is now possible using backslash.
  • NED: fixed deep parameter assignments: parameter references were interpreted in the wrong context. Deep parameter assignments are when an inifile-like pattern is used to name the parameter(s) to be set, as in:
  • network Inet {
  • parameters:
  • host[*].tcp.nagleEnabled = true;
  • ...
  • Resolved spurious errors: 'Class "…" not found?—?perhaps its code was not linked in, or the class wasn’t registered with Register_Class()' Added a check to ensure that the debug and the release versions of the simulation library are not loaded at the same time. This problem occurred when a model was built as 'release' and the debug version of 'opp_run' was used to start it. As a result, the simulation seemingly started but complained about missing classes.
  • Fix: Some classes were thrown out by the linker if OMNeT++ was statically built, and the simulation was complaining at runtime about the missing cCompoundModule class.
  • Eventlog recording: .elog file format change: message creations and duplications (cloning) are now recorded; MC (ModuleCreated) entries now precede GC (GateCreated) entries. IMPORTANT: The sequence chart in the IDE will only work on .elog files in the new format, existing event logs need to be re-recorded!
  • IDE/Animation Player:
  • This is a new component in the IDE, you can access it by right-clicking an .elog file and selecting "Open With / OMNeT++ Animation Player" from the context menu. This is a preliminary implementation (Technology Preview) not yet optimized for large files, the practical maximum file size it can handle is about 10MB.
  • IDE/C++ Development:
  • Added a new "Clean Local" item to the project’s context menu that does not clean referenced projects. This resolves the problem that CDT’s "Clean Project" command also cleans the referenced projects, e.g. if you have a Foo project that depends on INET, cleaning Foo also cleans INET which takes a long time to recompile. Now you can use the "Clean Local" command to clean Foo only.
  • Added new "OMNeT++ Code Formatter" profile. This coding convention follows the rules used in the OMNeT++ kernel and the INET Framework. (No tabs, etc.)
  • Added MachO64 binary parsers and error parsers. This makes it possible to debug a 64-bit executable on Mac OS X 10.6
  • Linux only: Added support for profiling with Valgrind. To activate this feature, select "Profile as… / OMNeT++ Simulation" from the Project Exporer context menu. This feature requires Valgrind to be installed on your system. (Note: the main IDE toolbar does not show a Profile button next to the Run and Debug buttons at this time, but profiling is still available via the Project Explorer context menu.)
  • The Makemake page in Project Properties can now fix the "Source Folders differ across configurations" problem in the project setup, which usually occurs when you add a build configuration to an existing project later. The dialog now displays a "Fix it" link.
  • IDE/Graphical Editor:
  • Several performance optimizations for the NED Editor. It can open much larger files than before. NED validation is done now in a background thread and does not block the UI.
  • Select 'NED Type Selection' dialog now works correctly on first open. It shows the defining projects for the types.
  • Enhanced drag and drop capabilities in NED Graphical Editor. You can drop NED types into a compound module either to create submodules (if you drop it into the submodule area), or to turn it into an inner type (if you drop on the title of the compound module).
  • The Graphical Editor now displays the file’s package name at the top.
  • Graphical Editor displays self-connections as arcs in the module’s upper right corner.
  • The resize/move feedback figures have been changed from a simple outline to translucent blue.
  • Added a 'Properties' dialog that can edit one or several objects at a time, and allows you to change graphical and type information. It also has a preview panel.
  • Enhanced editing of type fields in the 'Property View'. The editor correctly enumerates the possible choices and adds an import statement if necessary.
  • 'Open Type' and 'Open Supertype' have been reassigned to the F3 function key. Double-click now opens the 'Properties' dialog.
  • The IDE now uses the use native (C++) layouter code for placing unpinned submodules, which means better performance and consistency with the simulation runtime (Tkenv).
  • IDE/Inifile Editor:
  • Support for inifile improvements in this release, namely multiple section inheritance and better parsing for iteration variables
  • Performance improvements: inifile is now analyzed in the background so that it does not block the UI, and features that need its results (hover text, content assist, etc) have a timeout how long they are willing to wait for it (see bug #132 for details). It is now also possible to disable inifile analysis. Further performance and UI responsiveness improvements are planned.
  • IDE/Sequence Chart:
  • Added 'Goto Simulation Time' and 'Goto Event Number' in the context menu.
  • 'Go to Simulation Time' in the 'Event Log' view now supports relative values.
  • The Sequence Chart tool now knows about message creations and duplications (cloning), and as a result, in certain situations it is now able to better identify relationships between events and draw a better sequence chart. NOTE: Due to changes in the .elog file format, the tool will only work with newly recorded files. Existing event logs need to be re-recorded!
  • IDE/Launcher:
  • The command-line for launching the simulation now uses relative paths instead of absolute ones. This makes the starting command-line easier to understand.
  • IDE/Documentation Generator:
  • Added tilde notation as an alternative to automatic hyperlinking of module names in comments. The latter was often too agressive (e.g. linking to the IP module in the phrase "IP address" is wrong). Automatic hyperlinking can now be turned off in the generator, and then the user is expected to mark words to be hyperlinked with a tilde: "the ~IP module". The INET Framework has already been converted to use the tilde notation.
  • Added Javascript to autoload frameset page if a content page is opened by itself. This is useful when URLs to specific content pages are posted on the mailing list or sent over email.
  • Implemented @include in NED comments. Lines in the included file don’t have to start with "//", but otherwise they are processed exactly as NED comment text.
  • Fix: External pages (@externalpage) now appear unded the "Selected Topics" node of the navigation tree in the generated documentation.
  • Several minor fixes: recognize the (underline) HTML tag; sanitize the file names for @page; added/refined test cases
  • Tkenv:
  • Parallel simulation: Placeholder modules are now displayed with a semi- transparent icon (or if it’s a rectangle or oval, with dotted border).
  • Fix (bug #248): compute coordinates (and sizes) in double and not int; necessary if background scaling (bgs display string tag) is set up.
  • Better choice of default user interface font, especially on Linux.
  • The generic UI font and the font used in graphics are now configurable in the Simulation Options dialog.
  • The default font for log text is now proportional (same as the generic UI font), for better readability and space efficiency. It can be customized (switched back to a monospace font, etc) in the Simulation Options dialog.
  • Minor: menu items have been changed to title case
  • Tcl errors are now logged into .tkenvlog instead of dumping them on stdout.
  • Misc:
  • Added -g option to 'scavetool scalar' command. You can specify how the scalars are grouped into columns/variables.
  • The build system can now build large projects on windows. The 32K command-line limitation has been resolved.
  • Updated base system to Eclipse 3.6.1
  • Added a detailed IDE change log file doc/IDE-Changes