RealThinClient SDK v3.76 (available to developers with a RealThinClient subscription) has been extensively stress-tested using 9.900 concurrent connections over HTTPS with a stress-test running one full week without a break (24/7). There were NO errors throughout the whole stress-test, there were NO problems closing any of the RTC Clients nor the RTC Server and there were absolutely NO memory leaks on either of the Clients nor the Server (FastMM 4.94 used as Memory Manager with memory leak reporting and StreamSec Tools 2.1.9.240 used for SSL encryption).

In this stress-test, the RTC Server has responded to more than 394 million requests from RTC Clients, which have opened and closed more than 2,7 million connections to the Server. I have been changing test parameters on all Clients once every 24 hours, so that most RTC SDK properties and settings have been tested for cca 24 hours each.

Here is one Screenshot of a RTC Server showing how the RealThinClient SDK v3.76 is being stress-tested by simulating 9.900 concurrent clients, where each Client is sending a remote function call to the Server, waiting for the result and then sending the next call in a continuous loop, flooding the Server with requests (image shrinked here to reduce file size):

What you see above are 11 Client PCs, each running 3 instances of the AppClient demo, each AppClient instance using 64 threads in MultiThreaded mode to send remote function calls through 300 concurrent connections to the Server (11 x 3 x 300 = 9.900 connections). The Server is running in MultiThreaded mode and using 64 threads to handle all connections simultaneously.

Each vertical line on each AppClient instance represents a connection to the Server, where the red color shows the percentage of calls to be made in the current loop and the green/cyan color shows the percentage of results received in the current loop. AppClients were all working in multi-threaded mode and were set up to use different settings, while every connection is set up to make 50 remote calls to the Server per loop, and each loop is repeated one second after the last one was finished, which results in an endless loop of remote calls (until stopped).

To see more detailed Screenshots (original size, PNG compressed) and detailed Test Results, CLICK HERE.

Server:
Dual-Core AMD X2 at 4,4 GHz (2 x 2,2 GHz) with 2 GB RAM
Average processing speed: 518,5 req/sec
Average data transfer rate: 33,1 MBit/sec
Total requests processed: 653.960.000

10 Client PCs (200 connections each):
7 x Pentium III at 667 MHz with 256 MB RAM
3 x Pentium III at 650 MHz with 384 MB RAM
- connected to one 24-port 100 MBit switch

The purpose of this test was to see how stable the Clients and the Server are
when generating Extreme Load for a very long time (350 Hours), without a pause.
There were no problems, the test would still be running if I hadn't stopped it.

For performance tests, please check other test results (below).

Since all Clients were connected to the same Server during this test, all parameter combinations have been in
use at the same time, sending simple and complex data structures to the server, receiving simple and complex
results. Because of this and very high network load during the test, this was a good stress-test in a flooded
environment, but it should NOT be seen as a performance test, since it is not.

Information provided in the table above is only to show you how load was distributed between clients when they
are sending different-size requests. All results should be evaluated as a whole, showing you what would happen
if all these clients would be hitting the Server continually for 14 days, without a pause.

Since the RealThinClient SDK supports 12 simple data types (boolean, integer, largeint, float, currency, datetime,
string, text, widestring, variable, exteption, byte stream) and 3 complex data types (records, arrays and datasets),
where every element inside a complex data type can be of ANY other data type, including complex data types,
the resulting structure used in this stress-test was quite big (14-53 KB). And to test how sending and receiving
of all those data types works, the same data was packed again on the Server and sent back to the Client.

For performance tests, please check the other test results (below).

Server:
Dual-Core AMD X2 at 4,4 GHz (2 x 2,2 GHz) with 2 GB RAM
Average processing speed: 3278 req/sec

12 Client PCs:
9 x Pentium III at 667 MHz with 256 MB RAM
3 x Pentium III at 650 MHz with 384 MB RAM
- connected to one 24-port 100 MBit switch

Server:
Dual-Core AMD X2 at 4,4 GHz (2 x 2,2 GHz) with 2 GB RAM
Average processing speed: 5297 req/sec
Total connections in use: 600

12 Client PCs:
9 x Pentium III at 667 MHz with 256 MB RAM
3 x Pentium III at 650 MHz with 384 MB RAM
- connected to one 24-port 100 MBit switch

Complete Test Results are available for download here:
AppServerFastMM16TResults.zip

FastMM4 and FastMove units which I used to stress-test
RTC SDK components, can be download here:
FastMM4+FastMove.zip

With 13 clients and average speed of 4.500 req/sec
(see above), every time a client has sent a request to
the server, response came back in less than 3 ms.

Complete Test Results can be downloaded here: AppServerTest512T.zip

All 13 Client PCs were running the RTC SDK AppClient Demo with the Multiple Connection Flood test,
using 300 connections in Multithreaded mode (pool size set to 16 Threads) with automatic compression
and encryption to constantly flood the Server with remote function calls (total 3.900 connections).

Server was running the RTC SDK AppServer Demo in multithreaded mode
(using 16 Threads) with automatic encryption and compression.

Winner in those RTC SDK Tests is FastMM 4.56 (best performance and lowest memory usage)
and the worst possible results were achieved using the standard Delphi Runtime Library
(RTL - awful performance with highest memory usage).

AppServer Performance:
Different MMs, 16 Threads, 3.900 Connections:

Complete Test Results can be downloaded here: AppServerTest16T.zip

Server:
Pentium III at 667 MHz with 256 MB RAM

12 Client PCs:
3 x Pentium III at 650 MHz with 384 MB RAM
9 x Pentium III at 667 MHz with 256 MB RAM
- connected to one 24-port 100 MBit switch

Server:
Single-processor AMD at 1,2 GHz CPU with 768 MB RAM
Average processing speed: 822 req/sec
Total connections in use: 2.400

13 Client PCs:
3 x Pentium III at 650 MHz with 384 MB RAM
10 x Pentium III at 667 MHz with 256 MB RAM
- connected to one 24-port 100 MBit switch

Test started on Friday, October 7th 2005, 17:00 CET
Closed on Monday, October 10th 2005, 14:00 CET

Test running time: 2 days, 21 hours
Requests processed: 204,2 million

A number of smaller tests over the Internet and different LAN's have also
been completed without any problems. You are also welcome to test RTC SDK
in your environment. The easiest method of doing so is by using the ready-to-use
AppClient and AppServer demos, which you can download here.
Feel free to post your test-results to the RTC Newsgroups.