Release Notes for RTX64 2013 with Service Pack 1

SDK

• Added support for Windows Kernel driver to communicate with RTSS applications through a Real-Time Kernel API (RTKAPI) functions. For more information on the available API functions, see the section Windows Driver IPC API (RTKAPI) Reference in the RTX64 Help.
• Added new Real-time API functions:
• RtWaitForSingleObjectEx – allows a thread to wait on an object to be signaled with a time-out interval in 100-nanosecond units. (1625)
• RtWaitForMultipleObjectsEx – allows a thread to wait on one of multiple objects to be signaled with a time-out interval in 100-nanosecond units. (1625)
• RtQueryPerformanceCounter – retrieves the current value of the high-resolution performance counter (based on the processor’s time-stamp counter, TSC). (1600)
• RtQueryPerformanceFrequency – retrieves the frequency of the high-resolution performance counter (based on the processor’s time-stamp counter, TSC). (1600)
• RtShrinkLocalMemory – shrinks the RTSS local memory pool up to the size specified.
• RtAllocateLocalMemoryEx – allocates memory from a pre-allocated RTSS local memory pool to avoid SRI activity if allocating memory from the Windows memory pool. (1808)
• Added new Real-time Network Device (RTND) API functions:
• RtndReceiveFilterEx – called when an incoming Ethernet frame is received from the NIC driver. This function if implemented will be called instead of RtndRecieveFilter, once per frame received. It supplies an additional parameter when the filter routine is called. This additional parameter is a pointer to the network interface in question.
• RtndTransmitFilterEx – called when an outgoing Ethernet frame is received from the stack. This functionif implemented will be called instead of RtndTransmitFilter, once per frame transmitted. It supplies an additional parameter when the filter routine is called. This additional parameter is a pointer to the network interface in question.
• Modified the Managed Code Framework to support the use of COM clients. (2101)
• Provided support for an SDK version define RTX_SDK_VERSION for customers to use. (997)
• Added Visual Studio 2012 build support, including:
• RTX64 Application wizard (1573)
• Support for statically linked Debug and Release versions of the Microsoft Visual Studio C Runtime (1573)
• Added a new macro, Rtx64Platform, to locate libraries. (2069)
• Additional samples to show RTX64 functionality:
• RTK IPC – Real-time kernel driver sample that shows inter-process communication with an RTSS application.
• Simple Ping Pong – multiple thread sample that shows synchronization between 2 threads using an event.
• Simple Data Exchange – multiple process sample that shows synchronization and communication between 2 processes using events and shared memory.
• Mailbox – sample to show how customers could implement their own mailboxes to use within RTSS processes.
• Windows RTX64 using STL – sample to show how one can develop RTSS applications using the Microsoft Standard Template libraries.

SDK

• Resolved an issue where FastSemaphore calls returned BOOLEAN instead of BOOL. (1550)
• Resolved an issue where Managed Code Framework RTAPI objects could be garbage collected even when they had non-zero reference counts. (1679)
• Ensured that RegQueryValueEx returned the expected status when no buffer was supplied. (291)
• Resolved an issue where compiling RegQueryValueEx to use multi-byte characters added an extra character in the string. (1634)
• Resolved an issue where the Microsoft compiler inserted stack probes even when the /Gs and /Ge options were disabled. (1029)
• Resolved an issue where calls to FD_ISSET caused a linker error for RTSS applications. (1579)
• Fixed incorrect prototypes in RTAPI.h for RtWritePort Real-Time APIs. (1604)
• Resolved an issue where calling RegEnumValue caused a Blue Screen when optional parameters were not initialized. (1638)
• Resolved an issue where allocating memory with the function RtAllocateLocalMemory caused a Blue Screen. (1640)
• Resolved an issue where RtProcThreadAttributeUseLocalMemory was getting an unresolved reference due to WINDEF not being defined (1681)
• Resolved an issue where RtCreateProcess did not follow the global Local memory default setting if no flags were provided (1760)
• Resolved an issue where RtCreateProcess did not fail correctly when an invalid parameter was provided. (1548)
• Ensured that all RTAPI functions return proper error codes. (1754)
• Resolved an issue where RTX64 wizard-generated Visual Studio projects were unable to locate required libraries due to an incorrect path name. (1780)
• Resolved an issue where a Windows application window could not be closed while running an application that called the functions RtWaitForSingleObject and RtCreateEvent. (1792)
• Resolved an issue where RtGetLicenseFeatureStatusEx only returned information for the runtime no matter what product code was provided (1570)
• Resolved an issue where the Visual Studio RTX64 Application Wizard created an environment with double slashes in the additional paths. (1636)
• Resolved an issue where the RTX64 Application Wizard created a C++ project that would generate compiler warnings in debug mode. (1583)
• Resolved an issue where LoadLibary returned the wrong error code if the RTDLL could not be found. (1128)

Samples

• Resolved an error in the setup of sample project RTDLL. (1623)
• Resolved an issue where the Visual Studio version number was appended to .rtdll filenames when some example projects were built. (1470)
• Resolved an issue where the RtssServer sample failed to run beyond the MAXSOCKETS setting. (1487)

• RTX64 configuration settings are not retained when you upgrade to RTX64 2013 with Service Pack 1.
• You must either be a Windows Administrator or a member of the RTX64Administrators user group to run the RTX64 Control Panel. (2211)
• The default Stack size for RTSS applications has been increased to 8KB. (1721)
• To convert a device that RTX64 does not provide out-of-the-box support for, you must first create an INF file for that device. The INF file will install the RTX64pnp driver on the custom device. An INF template called sample.inf is installed with RTX64 SDK in the samples folder, C:\Program Files\IntervalZero\RTX64 SDK\1.1\Samples (by default). For more information, see Creating an INF File for Custom Devices. For assistance, please contact IntervalZero Support: http://www.intervalzero.com/technical-support/
• Devices that have been converted to RTX64 control in previous versions of RTX64 2013 cannot be upgraded to RTX64 2013 with Service Pack 1. Before upgrading, you must convert these devices back to Windows control. If no Windows driver exists for a device, you must uninstall it.

• If you are upgrading from RTX64 2013 with Update 1 to RTX64 2013 with Service Pack 1, and you want to convert a device that has previously been converted to RTX64 prior to RTX64 2013 with Service Pack 1, you will need to perform an additional step during device conversion following the upgrade. See Converting a Windows device to RTX64 for more information.

• The GUID for the RTX64 Plug and Play driver has been changed. If any devices are already converted to RTX64, they will need to be updated to reference the new driver. You may also still see a node for RTX PNP drivers in Windows Device Manager. (2136, 1690)
• The functions RtGetThreadPriority and RtSetThreadPriority should not be mixed with the Windows GetThreadPriority or SetThreadPriority functions. (1998)
• The RTAPI call RtUnMapSharedMemory has been removed from the product. RtCloseHandle should be used in its place. (1770)
• The RTX64 Managed Code Framework does not support applications that target the x86 platform and may fail with an unhandled exception. (1302)
• By default, RTX64 samples are installed under C:\Program Files\. As a result, you will be prompted to elevate permissions when you attempt to open them in Visual Studio on Windows 8 machines. If you choose not to elevate, you will not be able to build or save the sample projects. To work around this issue, move the RTX64 samples to another location outside of C:\Program Files. (1928)
• Using RtssKill to terminate a process may result in unexpected results. For instance, handles may not be properly closed. (1714)
• Using RtssKill to terminate the RT-TCP/IP Stack may cause a Green Screen. You should only terminate the Stack with RtssKill if it has become unresponsive and cannot be stopped through the Control Panel. (2205)
• You should not convert a device that is currently in use. (2238)
• Due to improvements in how RTX64 interacts with Windows power management options, the following power management settings are no longer necessary and have been removed:
• Prevent C1 Idle
• Prevent Windows idle thread from running and disable all Intel® SpeedStep® functionality
• Windows Task Manager shows different CPU usage on Subsystem startup depending on the Operating System:
• Windows 7 – the Task Manager no longer shows 100% CPU usage when the Subsystem is started
• Windows 8 – the Task Manager shows 100% CPU usage when the Subsystem is started. This is because Windows 8 CPU usage accounts for the time the CPU is not in C1-C3 power states.

• The path structure to the RTX64 libraries changed between RTX64 2013 with Update 1 and RTX64 2013 with Service Pack 1:

  RTX64 2013 with Service Pack 1 (Visual Studio 2012 and 2010) - $(Rtx64SDKDir)lib\$(Rtx64Platform)

  RTX64 2013 with Update 1 (Visual Studio 2010) - $(Rtx64SDKDir)lib\$(PlatformShortName)

  Using the Convert feature of Visual Studio to convert RTX64 projects that were created with older versions of Visual Studio can result in mismatched RTX64 compiler settings. Therefore, it is recommended that the Convert option in Visual Studio not be used to convert RTX64 projects.

• The RTX64 Managed Code samples, ManagedCodeFrameworkClientCPlusPlus_VS2012 and ManagedCodeFrameworkClientCSharp_VS2010, will not build with the Intel Compiler. (2060)
• Program samples are provided to show concepts only. They do not include full error checking that would normally exist in customer applications.
• Parameters to the function RtnGetDevicePrt have changed. (1781)
• The RTX64 subsystem must be running before you can debug an RTSS application in Visual Studio. (1045)
• Makefiles are not supported in Visual Studio 2012.

• On 3rd generation multi-core systems, e.g., Intel i5-3330, Windows 8 entered x2APIC mode. This version of RTX64 does not support x2APIC mode. If RTX64 fails to start on a 3rd generation multi-core system with Windows 8, you can check Event Viewer > Windows Logs > System to find out if RTX64 failed to start because the system is in x2APIC mode. (1908)

• If Windows drivers are not installed for any devices listed in the file RTX64Pnp.inf, the RTX64 installer may install the RTX64Pnp driver on those devices. If a Windows driver is then installed on the system, it will not be installed on the device. To resolve this issue, manually convert the device to Windows control. (1794)
• The default value for Watchdog timer support is set to Disabled in this release. If the watchdog timer functionality is enabled and you are using the RT-TCP/IP Stack, you will have to manually stop the stack by using RtssKill with the /showtcpip flag. (2132)
• If Visual Studio 2010 is open, and you have previously debugged an RTX64 application, you will not be able to stop the subsystem until Visual Studio is closed. (2116)
• Currently, there is no name resolution support in the Treck TCP/IP Stack. As a result, the API function gethostbyname works differently than in the 32-bit RTX product. (1610)
• Changes to Subsystem settings are not retained after RTX64 is upgraded.
• If a RTX64 component is locked to a dongle, and that dongle is removed from the machine, license information for that component is no longer displayed in the RTX64 Control Panel or RTX64Config command line utility. (2085)
• Selecting Shutdown on a Windows 8 machine causes the system to enter Sleep 3 mode, which RTX64 does not support. As a result, you will not be able to start RTX64 on the subsequent system boot up. To work around this issue, unplug the Windows 8 machine before attempting to boot up. (1975)
• The local memory Initial Size and Expansion Size values cannot exceed 4 gigabytes. This limitation will be resolved in a future release.
• On machines where .NET 4.0 is not already installed: if an error occurs during installation of .NET 4.0, the Runtime/SDK installation still proceeds until the end, when it fails with an error that the "Installation wizard is interrupted." Instead, the Runtime/SDK should end immediately if .NET 4.0 cannot be installed. This will be resolved in a future release. (2128)
• The RTX64 Pnp driver shows up with a question mark in the Device Manger view. This is due to an incorrectly provided image. The driver is fully functional. (1909)
• The friendly name for interfaces can only be 14 characters long. This will be corrected in a future release. (2168)
• The product uninstall does not remove the RTX64 Power Policy created during installation (2133)
• If a filter driver is changed in the Control Panel, the text does not update until you refresh the screen.
• A Green Screen occurs when the RT-TCP/IP Stack is started and stopped multiple times in succession when two network interfaces are enabled on two separate NIC cards. To resolve this issue, increase the default Local Memory setting to 2048 (default). This will be fixed in a future release. (2150)
• This version of RTX64 does not support calls to Connect via the Shutdown Handler. This will be fixed in a future release. (2143)
• You cannot use the functions RtSetThreadPriority and RtGetThreadPriority to configure how Windows threads are prioritized within the Real-time Subsystem with this release. This capability will be included in a future version. (2057)
• Windows 8.1 is not supported as of this version.
• The function RegCreateKeyEx cannot create above one level. It can only create one missing key in the specified path. (1718)
• Running the RtkIPC sample may produce unexpected results on Windows 8 machines. (1732)
• The Real-time functions RtGetBusDataByOffset and RtSetBusDataByOffset are only supported in the RTSS environment. Neither function can be called from a Windows application linked to RTX64.
• The Real-time functions RtGetBusDataByOffset and RtSetBusDataByOffset, RtAttachInterrupt,, RtReleaseInterrupt, and RtTranslateBusAddress are only supported in the RTSS environment. These functions cannot be called from a Windows application linked to RTX64. (2155)

• Certain Network Interface Cards (NICs) will be automatically converted to RTX64 control when Windows is rebooted after RTX64 2013 with Service Pack 1 is installed. This occurs because the Hardware ID of the NIC in the Windows driver's INF file is not more specific than the Hardware ID of the NIC in the RTX64 driver's INF file. This causes Windows to treat both drivers as equally capable of controlling the NIC. In this case, Windows chooses a newer driver over an older driver. Because the RTX64 driver is newer, Windows assigns ownership of the NIC to RTX64 automatically. If the NIC needs to be used under Windows, it must be converted back to its original driver using the Windows Device Manager. (2199)

• When adding entries to the ARP table, only IPs in the same subnet as the RTX64 node are allowed. (2280)
• The CRT library fails debug assertions when an application linked against the debug CRT library causes one of the secure CRT functions to have a parameter validation error. The result is a Green Screen. This will be fixed in a future release. (2044)
• Manually uninstalling the RTX64 2013 SDK or RTX64 2013 SDK with Update 1 causes the corresponding Runtime version to stop working. If you want to use the Runtime after uninstalling the SDK, you must also uninstall and then reinstall the Runtime. (2272)
• The RTX64 RtIGB driver does not support Jumbo Frames.