Chapter 5 Linux Platforms

5.1 Summary of Linux Platforms and Supported Features

The following tables show the supported products/features for each architecture. A ● means supported in this release, an empty cell means unsupported in this release.

Table 5.1 Linux Systems - Supported Features

RTI Architecture [1]	Supported Features
Languages
	Java [2]	Python [3]	.NET (C#) [4]	C/C++ [5]	Modern C++ [6], [7]	Protocol Buffers Extension [8]
Linux® (Intel) Red Hat® Enterprise Linux 8, 9, 10; Ubuntu® 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●	●	●
Linux (Arm®) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0	●	●	●	●	●	●
Transports
	UDP/IPv4	UDP/IPv6	Multicast	TCP/IPv4	Shared Memory (w/ zero copy) [9]
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0	●	●	●	●	●
Infrastructure Services
	Persistence Service [10]	Routing Service	Recording and Replay Services	Web Integration Service
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0	●	●	●	●
Connext Professional Libraries
	Request/Reply	Monitoring Library	Distributed Logger	LBED [11]	Monitoring Library 2.0
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●	See "Observability Framework" rows below
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0	●	●	●	●
Core Library Features
	Monotonic Clock	CPU Core Affinity	Durable writer history & reader state	RTI DDS thread name	Backtrace [12]	Cmake Find Package
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●	● [13]	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0	●	●	●	●	● [13]
Tools
	Shapes Demo	Launcher	Monitor	Admin Console	System Designer	rtiddsgen server	Utilities (rtiddsping, rtiddsspy)
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●	● [14]	●	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0							●
Observability Framework
	Observability Collector Service	Monitoring Library 2.0
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0		●
Security Extensions
	Security Plugins (for OpenSSL) [15]	Security Plugins (for wolfSSL) [16]	TLS Support [15]	Security Plugins SDK [17]
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0	●		●
Add-ons
	Cloud Discovery Service	Real-Time WAN Transport	Ada Language Support	Limited Bandwidth Plugins	Queuing Service (Experimental)
Linux (Intel) Red Hat Enterprise Linux 8, 9, 10; Ubuntu 22.04 LTS, 24.04 LTS x64Linux4gcc8.5.0	●	●	●	●	●
Linux (Arm) Ubuntu 22.04 LTS, 24.04 LTS armv8Linux4gcc8.5.0		●		●

See Supported Platforms and Customized Installation in RTI Connext for Debian Linux for more information on Debian support; see also Supported Platforms in the RTI Connext Core Libraries Release Notes. See https://hub.docker.com/u/rticom (click the product, such as DDS Spy, then the Tags tab) for the Linux architectures that Docker supports; see also rticonnextdds-containers on GitHub.

Footnotes for the above table:

1	Supports DDS 1.4, RTPS 2.5, and DDS X-Types 1.4.
2	Built with Eclipse Temurin OpenJDK 21.0.7, compatible with Java 8 and above. Also tested with AdoptOpenJDK 17.0.6 and 25.0.1.
3	Supported on Python 3.10-3.14. Free-threaded (no-GIL) builds of CPython 3.13+ are not currently supported.
4	The C# API is provided as multi-targeted .NET Standard 2.0 and 2.1 libraries, built using the .NET 10 SDK. This allows consumption from the following runtimes, per Microsoft compatibility guidance: .NET 5 and newer, .NET Core 2.1 and newer, and .NET Framework 4.8.1 and newer. Unity projects can consume the libraries on either .NET Standard 2.0 or 2.1 profiles depending on the Unity version and API Compatibility Level settings. Unity versions 2021.2 and later include support for .NET Standard 2.1, while earlier versions target .NET Standard 2.0.
5	Supports C++98 compilers or newer.
6	Tested with C++11 unless stated otherwise.
7	Supporting Modern C++ means supporting the RPC feature unless otherwise stated.
8	Only provides mapping for Modern C++. The IDL converted from a .proto file can be used with the standard mapping in the rest of the languages.
9	Zero-copy transfer over shared memory is NOT supported for Java, Ada, .NET and Python programming languages. It is only supported for C, Traditional C++, and Modern C++ programming languages.
10	Tested with filesystem only in PERSISTENT mode.
11	Supports dynamic linking only.
12	If you want backtrace information: on all Linux architectures, compile with -fno-omit-frame-pointer and add linker flag -rdynamic. For Linux architectures on Arm CPUs, also compile with “-funwind-tables”. On all Windows architectures, you need the Dbghelp.dll and NtDll.dll libraries.
13	For architectures using gcc 6 or higher:if you want to display correct backtrace information in Connext logs, link the executable with “-no-pie” to prevent PIE generation.
14	See the RTI System Designer Release Notes for supported browsers.
15	Tested with OpenSSL 3.5.5 unless stated otherwise.
16	Tested with WolfSSL 5.8.2.
17	Tested with both OpenSSL 3.5.5 and WolfSSL 5.8.2.

5.1.1 Monotonic Clock Support

See Configuring the Clock per DomainParticipant, in the RTI Connext Core Libraries User's Manual for information on the monotonic clock.

5.1.2 Support for 'Find Package' CMake Script

For information on using the 'Find Package' CMake script, see 2.5 Building with CMake.

5.1.3 Backtrace Support

Note the following for platforms that support the backtrace feature:

• If you are using GCC 6 or newer, you must link the executable with -no-pie in order to correctly generate backtraces. See the Note below Table 5.2 Building Instructions for Linux Architectures.
• You will also need to compile with -fno-omit-frame-pointer.
• For Linux architectures on Arm CPUs, also use the -funwind-tables compiler option. This creates a table that allows the program to walk back through the function call stack from a given execution point.
• Symbol names may be unavailable without the use of special linker options. RTI has compiled Linux architectures using the linker option -rdynamic to display backtrace information. To display backtrace information on your Linux architecture, you must also compile with -rdynamic.

See Logging a Backtrace for Failures, in the RTI Connext Core Libraries User's Manual.

5.2 Building Applications for Linux Platforms

First, see the basic instructions in Chapter 2 Building Applications—Notes for All Platforms.

Then make sure that:

• Connext 7.x.y is installed (where 7.x.y stands for the version number of the current release). For installation instructions, refer to the RTI Connext Installation Guide.
• A “make” tool is installed. RTI recommends GNU Make. If you do not have it, you may be able to download it from your operating system vendor. Learn more at www.gnu.org/software/make/ or download from ftpmirror.gnu.org/make as source code.
• The NDDSHOME environment variable is set to the root directory of the Connext installation (such as /home/user/rti_connext_dds-7.x.y).
  • To confirm, type this at a command prompt:

  echo $NDDSHOME
  env | grep NDDSHOME

• If it is not set or is set incorrectly, type:

export NDDSHOME=<correct directory>

5.2.1 Required Libraries and Compiler Flags

To compile a Connext application of any complexity, either modify the auto-generated makefile created by running RTI Code Generator or write your own makefile. Table 5.2 Building Instructions for Linux Architectures lists the compiler flags and libraries you will need to link into your application.

Both release and debug versions of the libraries are provided. For Connext, debug libraries are created with debug symbols to facilitate debugging with gdb, for example. Release libraries do not contain debug information.

The Connext debug libraries are intended solely for development and debugging purposes. These libraries are not optimized for performance or resource consumption and may include additional diagnostic information that can affect runtime behavior. They are not intended for use in production environments. Please ensure that only the release libraries are used in production deployments. Debug libraries can be identified by the suffix "d" in their names.

Debug symbols for the release libraries are also provided as an alternative to the debug libraries, allowing source-level debugging without the performance overhead of the debug libraries.

Verified Compiler Flags:

Compiler flags outside those documented in Table 5.2 Building Instructions for Linux Architectures have not been verified by RTI and can cause undefined behavior.

Table 5.2 Building Instructions for Linux Architectures

API	Library Format	Required RTI Libraries or Jar Files 1 Choose *cpp*.* for the Traditional C++ API or *cpp2*.* for the Modern C++ API., 2 RTI C/C++/Java libraries are in <NDDSHOME>/lib/<architecture>. The jar files are in <NDDSHOME>/lib/java.	Required System Libraries	Required Compiler Flags
C++ (Traditional and Modern APIs)	Static Release	libnddscorez.a libnddscz.a libnddscppz.a or libnddscpp2z.a librticonnextmsgcppz.a or librticonnextmsgcpp2z.a	-ldl -lm -lpthread -lrt	For 64-bit architectures: -DRTI_LINUX  -DRTI_UNIX -m64 -DRTI_64BIT   For any Linux platform with GCC 6 or higher linker flag (see Note below table), also add: -no-pie   For all architectures, if you want backtrace information, also add: Compiler flag: -fno-omit-frame-pointer Linker flag: -rdynamic Arm architectures: -funwind-tables (see 5.1.3 Backtrace Support)
	Static Debug	libnddscorezd.a libnddsczd.a libnddscppzd.a or libnddscpp2zd.a librticonnextmsgcppzd.a or librticonnextmsgcpp2zd.a
	Dynamic Release	libnddscore.so libnddsc.so libnddscpp.so or libnddscpp2.so librticonnextmsgcpp.so or librticonnextmsgcpp2.so
	Dynamic Debug	libnddscored.so libnddscd.so libnddscppd.so or libnddscpp2d.so librticonnextmsgcppd.so or librticonnextmsgcpp2d.so
C	Static Release	libnddscorez.a libnddscz.a librticonnextmsgcz.a	-ldl -lm -lpthread -lrt	For 64-bit architectures: -DRTI_LINUX  -DRTI_UNIX -m64 -DRTI_64BIT   For any Linux platform with GCC 6 or higher linker flag (see Note below table), also add: -no-pie   For all architectures, if you want backtrace information, also add: Compiler flag: -fno-omit-frame-pointer Linker flag: -rdynamic (see 5.1.3 Backtrace Support)
	Static Debug	libnddscorezd.a libnddsczd.a librticonnextmsgczd.a
	Dynamic Release	libnddscore.so libnddsc.so librticonnextmsgc.so
	Dynamic Debug	libnddscored.so libnddscd.so librticonnextmsgcd.so
Java	Release	nddsjava.jar rticonnextmsg.jar	N/A	None required
	Debug	nddsjavad.jar rticonnextmsgd.jar

Note:

For Linux platforms with GCC 6 or higher, it's possible to configure the compiler driver to link, by default, executables with PIE (position independent executable) support on amd64 and ppc64el architectures. Depending on the distributor of the GCC package, automatic PIE generation may or may not be enabled.

To correctly generate backtraces, PIE executables cannot be used with RTI's libraries. This is due to Address Space Layout Randomization (ASLR), which prevents the correct generation of backtraces of our binaries on certain systems. For this reason, RTI has linked Linux executables using the -no-pie flag when the GCC version is 6 or higher.

If you are using GCC 6 or higher and you want to generate correct backtraces in Connext logs, you should link the executable with -no-pie to prevent PIE generation.

5.2.2 Additional Libraries for Other Features

This section discusses libraries for features that are not supported for every platform. Refer to Table 5.1 Linux Systems - Supported Features to see if these libraries are supported on your platform.

If you plan to use the additional RTI libraries described in this section, they must be linked before the required RTI libraries (see Table 5.2 Building Instructions for Linux Architectures) in your included libraries for linking.

Make sure you are consistent in your use of static, dynamic, debug and release versions of the libraries. For example, if your Connext application is linked with the static release version of the Connext libraries, you will need to also use the static release version of the library. Do not link both static and dynamic libraries. Similarly, do not mix release and debug libraries.

5.2.2.1 Libraries Required for Distributed Logger

To use the Distributed Logger APIs, link against the additional libraries in Table 5.3 Additional Libraries for using RTI Distributed Logger .

Table 5.3 Additional Libraries for using RTI Distributed Logger

Language	Static		Dynamic
	Release	Debug	Release	Debug
C	librtidlcz.a	librtidlczd.a	librtidlc.so	librtidcd.so
C++ (Traditional API)	librtidlcz.a librtidlcppz.a	librtidlczd.a librtidlcppzd.a	librtidlc.so librtidlcpp.so	librtidlcd.so librtidlcppd.so
Java	N/A	N/A	distlog.jar distlogdatamodel.jar	distlogd.jar distlogdatamodeld.jar

5.2.2.2 Libraries Required for Monitoring

If you are statically linking your application with DDS libraries and you want to add monitoring to your application, you will also need to statically link the monitoring library. The library cannot be loaded dynamically strictly through the QoS profile because it also depends on DDS to publish its data. Therefore, it depends on DDS; the DDS functionality would cause duplicate symbols to be found, resulting in the termination of the process.

Table 5.4 Additional Libraries for Using Monitoring

Library Format	Monitoring Libraries3 These libraries are in <NDDSHOME>/lib/<architecture>.
Dynamic Release	librtimonitoring.so
Dynamic Debug	librtimonitoringd.so
Static Release	librtimonitoringz.a
Static Debug	librtimonitoringzd.a

Table 5.5 Additional Libraries for Using Monitoring Library 2.0

Library Format	Monitoring Libraries 2.04 These libraries are in <NDDSHOME>/lib/<architecture>.
Dynamic Release	librtimonitoring2.so
Dynamic Debug	librtimonitoringd2.so
Static Release	librtimonitoringz2.a
Static Debug	librtimonitoringzd2.a

5.2.2.3 Libraries Required for Real-Time WAN Transport

If you choose to use Real-Time WAN Transport, you must download and install a separate package that contains the transport libraries. See the RTI Connext Installation Guide for details.

Using Real-Time WAN Transport requires one of the libraries in Table 5.6 Additional Libraries for Using Real-Time WAN Transport APIs. Select the file appropriate for your chosen library format.

For more information, see Enabling Real-Time WAN Transport, in the RTI Connext Core Libraries User's Manual.

Table 5.6 Additional Libraries for Using Real-Time WAN Transport APIs

Library Format	Real-Time WAN Transport Libraries5 These libraries are in <NDDSHOME>/lib/<architecture>.
Dynamic Release	libnddsrwt.so
Dynamic Debug	libnddsrwtd.so
Static Release	libnddsrwtz.a
Static Debug	libnddsrwtzd.a

5.2.2.4 Libraries Required for TCP Transport and TLS Support

To use the TCP Transport APIs, link against the additional libraries in Table 5.7 Additional Libraries for using RTI TCP Transport APIs.

Table 5.7 Additional Libraries for using RTI TCP Transport APIs

Library Format	RTI TCP Transport Libraries6 These libraries are in <NDDSHOME>/lib/<architecture>.
Dynamic Release	libnddstransporttcp.so
Dynamic Debug	libnddstransporttcpd.so
Static Release	libnddstransporttcpz.a
Static Debug	libnddstransporttcpzd.a

If you are using RTI TLS Support, see Table 5.8 Additional Libraries for using RTI TCP Transport APIs with TLS Enabled. Select the files appropriate for your chosen library format.

RTI TLS Support is an optional product for use with the TCP transport that is included with Connext. If you choose to use TLS Support, it must be installed on top of a Connext installation with the same version number; it can only be used on architectures that support TCP transport.

Table 5.8 Additional Libraries for using RTI TCP Transport APIs with TLS Enabled

Library Format	RTI TLS Libraries7 These libraries are in <NDDSHOME>/lib/<architecture>.	OpenSSL Libraries8 OpenSSL libraries are in <NDDSHOME>/third_party/openssl-3.5.5/<architecture>/<format>/lib.
Dynamic Release	libnddstls.so	libssl.so libcrypto.so
Dynamic Debug	libnddstlsd.so
Static Release	libnddstlsz.a
Static Debug	libnddstlszd.a

5.2.2.5 Libraries Required for Zero Copy Transfer Over Shared Memory

The Zero Copy Transfer Over Shared Memory feature is supported on all the platforms in Chapter 5 Linux Platforms.

To use this feature, link against the additional library in Table 5.9 Additional Libraries for Zero Copy Transfer Over Shared Memory.

Table 5.9 Additional Libraries for Zero Copy Transfer Over Shared Memory

Library Format	Zero Copy Transfer Over Shared Memory Libraries9 These libraries are in <NDDSHOME>/lib/<architecture>.
Dynamic Release	libnddsmetp.so
Dynamic Debug	libnddsmetpd.so
Static Release	libnddsmetpz.a
Static Debug	libnddsmetpzd.a

5.2.2.6 Debug Symbols for Release Dynamic Libraries

Debug symbols for the release dynamic libraries are available as separate packages. These packages allow you to debug applications linked against the release (non-debug) versions of the libraries without the performance overhead of the debug builds.

5.2.2.6.1 Installing Debug Symbol Packages

To include debug symbols for the release dynamic libraries bundled in an .rtipkg, you need to install the corresponding <package_name>-debuginfo.rtipkg available on the RTI Customer Portal.

Once installed, the debug symbol (.dbg) files are placed alongside the corresponding release shared libraries in <NDDSHOME>/lib/<architecture>/. For example, installing rti_connext_dds-<version>-pro-target-debuginfo-<arch>.rtipkg places libnddsc.so.dbg next to libnddsc.so.

5.2.2.6.2 Using Debug Symbols with gdb

gdb can automatically locate .dbg files if they follow the GNU debug link convention. To load debug symbols from a .dbg file manually during a gdb session, use the symbol-file or add-symbol-file commands:

(gdb) add-symbol-file <NDDSHOME>/lib/<architecture>/libnddsc.so.dbg

Alternatively, configure gdb to search a directory for debug symbol files by setting the debug file directory:

(gdb) set debug-file-directory <NDDSHOME>/lib/<architecture>

When debugging with release libraries and separate debug symbols, note the following:

• Source-level debugging and backtraces are available, but some local variables and inlined functions may be optimized away due to compiler optimizations in release builds.
• To get more complete backtraces, compile your application with -fno-omit-frame-pointer and link with -rdynamic. See 5.1.3 Backtrace Support for more information.
• Make sure the .dbg file version matches the corresponding shared library exactly; mismatched versions will result in incorrect or missing debug information.

5.2.3 Linux Compatibility and Determining Factors

RTI has concluded that there are four factors that can be used to determine the compatibility of RTI's Linux core libraries on a specific Linux distribution or system. You can use this information to identify which Connext Linux libraries are suitable for your system. If a system matches the compatibility factors, RTI has a high level of confidence that the core libraries will work with no issues.

RTI has identified four Linux compatibility factors:

• CPU architecture (such as x64, Arm v8)
• Minimum GLIBC version
• GLIBCXX version
• Floating-Point scheme

5.2.3.1 Compatibility factors explained

The CPU architecture is the CPU family of the target system. Note that this important value is not for the physical CPU used to run, but the configuration of the system where it will be executed. For example, you may have an x64 CPU but your system kernel may run as if it were an x86 CPU. In this case, a 32-bit version of the Connext library should be selected.

The minimum GLIBC is the minimum required value of the GLIBC library used in the target system. If the target system's GLIBC version is less than the minimum version required by Connext, run-time errors can occur, such as undefined symbol errors.

The GLIBCXX range is the range of the Standard C++ Library that the target system must support. In some cases this value is a range and in others it’s a minimum value just like the minimum GLIBC support.

The floating-point scheme defines how the assembly code is generated relative to the floating-point registers and instructions; this should only be a concern on Arm v7 architectures. The options available are soft floating-point and hard floating-point. All newer architectures use hard floating-point.

Table 5.10 Compatibility Ranges

Library Name	CPU	Minimum GLIBC	GLIBCXX Range
x64Linux4gcc8.5.0	x64	2.28	6.0.25 <= X
armv8Linux4gcc8.5.0	Arm v8	2.28	6.0.25 <= X

5.2.3.2 How to determine the GLIBC version on your target system

There are two ways to determine the GLIBC version in a target system. On most systems, you can run ldd --version. If the command ldd is not available, you must find where the libc.so library is located, then execute it. This will provide you the version of the library in the terminal. Note that you must perform this process on the target system in the case of cross-compiled architectures.

As an example, you can see the following output from an Ubuntu 20.04 system:

$ ldd --version

ldd (Ubuntu GLIBC 2.31-0ubuntu9.2) 2.31

Copyright (C) 2020 Free Software Foundation, Inc.

This is free software; see the source for copying conditions.  There is NO

warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Written by Roland McGrath and Ulrich Drepper.

$ ./lib/x86_64-linux-gnu/libc.so.6

GNU C Library (Ubuntu GLIBC 2.31-0ubuntu9.2) stable release version 2.31.

Copyright (C) 2020 Free Software Foundation, Inc.

This is free software; see the source for copying conditions.

There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compiled by GNU CC version 9.3.0.

libc ABIs: UNIQUE IFUNC ABSOLUTE

For bug reporting instructions, please see:

<https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>.

Given the output of both commands, we can say that the GLIBC version of this system is 2.31.

5.2.3.3 How to determine the GLIBCXX version on your target system

To determine the GLIBCXX version of the target system, you must find the libstdc++.so.6.0.XX library on your system. On some systems, you may have a libstdc++.so file, which is a symbolic link to the actual library.

The name of the libstdc++ library provides the version number, such as "6.0.XX" at the end of its name. Note that you must perform this process in the target system in the case of cross-compiled architectures. As an example, you can see the following output from an Ubuntu 20.04 system:

$ ls -l lib/x86_64-linux-gnu/libstdc++.so.6

lrwxrwxrwx 1 root root 19 May 29  2021 lib/x86_64-linux-gnu/libstdc++.so.6 -> libstdc++.so.6.0.28

Given this output, we can determine that the GLIBCXX version for this system is 6.0.28.

5.2.4 How the Connext Libraries were Built

Table 5.11 Library-Creation Details for Linux Architectures provides details on how RTI built the Linux libraries. This table is provided strictly for informational purposes. You do not need to use these parameters to compile your application. You may find this information useful if you are involved in any in-depth debugging.

Table 5.11 Library-Creation Details for Linux Architectures

RTI Architecture	Library Format	Compiler Flags Used by RTI
armv8Linux4gcc8.5.0	Static Release	-O3 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -funwind-tables -fno-strict-aliasing -fno-semantic-interposition -O3 -DNDEBUG -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"armv8Linux4gcc8.5.0\" -Werror=implicit-function-declaration
	Static Debug	-O0 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -funwind-tables -fno-strict-aliasing -fno-semantic-interposition -O0 -g -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"armv8Linux4gcc8.5.0\" -Werror=implicit-function-declaration
	Dynamic Release	-O3 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -funwind-tables -flto=auto -fno-strict-aliasing -fno-semantic-interposition -O3 -DNDEBUG -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"armv8Linux4gcc8.5.0\" -Werror=implicit-function-declaration
	Dynamic Debug	-O0 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -funwind-tables -fno-strict-aliasing -fno-semantic-interposition -O0 -g -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"armv8Linux4gcc8.5.0\" -Werror=implicit-function-declaration
x64Linux4gcc8.5.0	Static Release	-O3 -m64 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -O3 -DNDEBUG -fno-strict-aliasing -fno-semantic-interposition -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"x64Linux4gcc8.5.0\" -Werror=implicit-function-declaration
	Static Debug	-O0 -m64 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -fno-strict-aliasing -fno-semantic-interposition -O0 -g -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"x64Linux4gcc8.5.0\" -Werror=implicit-function-declaration
	Dynamic Release	-O3 -m64 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -flto=auto -fno-strict-aliasing -fno-semantic-interposition -O3 -DNDEBUG -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"x64Linux4gcc8.5.0\" -Werror=implicit-function-declaration
	Dynamic Debug	-O0 -m64 -Wall -Wno-unknown-pragmas -fno-omit-frame-pointer -fno-strict-aliasing -fno-semantic-interposition -O0 -g -fPIC -DLINUX -DPtrIntType=long -DTARGET=\"x64Linux4gcc8.5.0\" -Werror=implicit-function-declaration
All supported Linux architectures for Java	Dynamic Release	-target 1.8 -source 1.8
	Dynamic Debug	-target 1.8 -source 1.8 -g

 

5.3 Running Your Applications

For the environment variables that must be set at run time, see Table 5.12 Running Instructions for Linux Architectures.

Table 5.12 Running Instructions for Linux Architectures

RTI Architecture	Library Format	Environment Variables
All supported Linux architectures when using Java	N/A	LD_LIBRARY_PATH= ${NDDSHOME}/lib/<architecture>: ${LD_LIBRARY_PATH} Note: For all 64-bit Java architectures (...64Linux...), use -d64 in the command line.
All supported Linux architectures when not using Java	Static (Release & Debug)	None required
	Dynamic (Release & Debug)	LD_LIBRARY_PATH= ${NDDSHOME}/lib/<architecture>: ${LD_LIBRARY_PATH}

 

5.3.1 Shared Memory Support

To see a list of shared memory resources in use, please use the 'ipcs' command. To clean up shared memory and shared semaphore resources, please use the 'ipcrm' command.

The shared memory keys used by Connext are in the range of 0x400000. For example:

ipcs -m | grep 0x004

The shared semaphore keys used by Connext are in the range of 0x800000; the shared mutex keys are in the range of 0xb00000. For example:

ipcs -s | grep 0x008

ipcs -s | grep 0x00b

Please refer to the shared-memory transport online documentation for details on the shared memory and semaphore keys used by Connext.

5.4 Thread Configuration

5.4.1 Thread Settings, Thread-Priority Definitions, and Thread Kinds

Table 5.13 Thread Settings for Linux Platforms lists the thread settings for Linux platforms.

See also: Table 5.14 Thread-Priority Definitions for Linux Platforms and Table 5.15 Thread Kinds for Linux Platforms.

Table 5.13 Thread Settings for Linux Platforms

Applicable Thread	DDS_ThreadSettings_t	Platform-Specific Setting
Asynchronous Publisher, Asynchronous flushing thread	mask	OS default thread type
	priority	OS default thread priority
	stack_size	OS default thread stack size
	cpu_list	Empty CPU list (Supported on Linux platforms)
	cpu_rotation	DDS_THREAD_SETTINGS_CPU_NO_ROTATION
Database thread	mask	DDS_THREAD_SETTINGS_STDIO
	priority	OS default thread priority
	stack_size	OS default thread stack size
	cpu_list	Empty CPU list
	cpu_rotation	DDS_THREAD_SETTINGS_CPU_NO_ROTATION
Event thread	mask	DDS_THREAD_SETTINGS_STDIO | DDS_THREAD_SETTINGS_FLOATING_POINT
	priority	OS default thread priority
	stack_size	OS default thread stack size
	cpu_list	Empty CPU list
	cpu_rotation	DDS_THREAD_SETTINGS_CPU_NO_ROTATION
ReceiverPool threads	mask	DDS_THREAD_SETTINGS_STDIO | DDS_THREAD_SETTINGS_FLOATING_POINT
	priority	OS default thread priority
	stack_size	OS default thread stack size
	cpu_list	Empty CPU list
	cpu_rotation	DDS_THREAD_SETTINGS_CPU_NO_ROTATION

 

Table 5.14 Thread-Priority Definitions for Linux Platforms

Thread-Priority Definition	Operating-System Priority
THREAD_PRIORITY_DEFAULT	If any of these constants are used to set the priority of the thread in the QoS, the OS's default thread priority will be used.
THREAD_PRIORITY_HIGH
THREAD_PRIORITY_ABOVE_NORMAL
THREAD_PRIORITY_NORMAL
THREAD_PRIORITY_BELOW_NORMAL
THREAD_PRIORITY_LOW

 

Table 5.15 Thread Kinds for Linux Platforms

Thread Kinds	Operating-System Configuration10 See the Linux programmer’s manuals for more information.
DDS_THREAD_SETTINGS_FLOATING_POINT	N/A
DDS_THREAD_SETTINGS_STDIO	N/A
DDS_THREAD_SETTINGS_REALTIME_PRIORITY	Set schedule policy to SCHED_FIFO
DDS_THREAD_SETTINGS_PRIORITY_ENFORCE	N/A

5.4.2 Using REALTIME_PRIORITY

If the mask field includes DDS_THREAD_SETTINGS_REALTIME_PRIORITY, a value must also be explicitly specified for the "priority" field in the QoS. (This is because using DDS_THREAD_SETTINGS_REALTIME_PRIORITY changes the scheduler used by Linux for the thread to SCHED_FIFO. If the priority field is not explicitly set, it will default to a value of 0, but this is an invalid value for a priority when using SCHED_FIFO.) Note that running with REALTIME_PRIORITY requires the appropriate privileges: the process will need to be run with root privileges on Linux in order to set the scheduler.

5.4.3 Automatic Thread-Specific Storage Cleanup

Linux systems support automatic thread-specific storage cleanup. Use of the DomainParticipantFactory::unregister_thread API is therefore not required to clean up thread-specific storage in user threads (although it is safe to do so).

5.5 Socket Buffer Size Configuration

See Table 5.16 UDP send_socket_buffer_size and Table 5.17 UDP receive_socket_buffer_size. For more information on the send_socket_buffer_size and receive_socket_buffer_size properties, see Setting Builtin Transport Properties with the PropertyQosPolicy, in the RTI Connext Core Libraries User's Manual.

Table 5.16 UDP send_socket_buffer_size

Property	Behavior
NDDS_TRANSPORT_UDPV4_SOCKET_BUFFER_SIZE_OS_DEFAULT	Uses default send socket buffer size net.core.wmem_default
NDDS_TRANSPORT_UDPV4_SOCKET_BUFFER_SIZE_OS_MAX	Uses maximum send socket buffer size net.core.wmem_max
NDDS_TRANSPORT_UDPV6_SOCKET_BUFFER_SIZE_OS_DEFAULT	Uses default send socket buffer size net.core.wmem_default
NDDS_TRANSPORT_UDPV6_SOCKET_BUFFER_SIZE_OS_MAX	Uses maximum send socket buffer size net.core.wmem_max

Table 5.17 UDP receive_socket_buffer_size

Property	Behavior
NDDS_TRANSPORT_UDPV4_SOCKET_BUFFER_SIZE_OS_DEFAULT	Uses default receive socket buffer size net.core.rmem_default
NDDS_TRANSPORT_UDPV4_SOCKET_BUFFER_SIZE_OS_MAX	Uses maximum receive socket buffer size net.core.rmem_max
NDDS_TRANSPORT_UDPV6_SOCKET_BUFFER_SIZE_OS_DEFAULT	Uses default receive socket buffer size net.core.rmem_default
NDDS_TRANSPORT_UDPV6_SOCKET_BUFFER_SIZE_OS_MAX	Uses maximum receive socket buffer size net.core.rmem_max

5.6 Network Performance Optimization

See Optimizing Your OS For Network Performance in the RTI Perftest documentation.