CORBA Comparison Project Windows Visual C++ Platform

Transcription

1 CORBA Comparison Project Windows Visual C++ Platform Orbix 5.1 TAO VisiBroker 5.1 Version: Final release Date: January 30, 2003 Distributed Systems Research Group Department of Software Engineering Faculty of Mathematics and Physics Charles University, Prague, Czech Republic

2 CORBA Comparison Project, Windows Visual C++ Platform Disclaimer This report is provided "as is", without warranty of any kind, either expressed or implied. This includes, but is not limited to, the implied warranties of merchantability and fitness for a particular purpose. In no event shall any author or copyright holder be liable for damages arising out of the use or the inability to use the report. Both the results of the measurements in this report and their interpretation depend on a number of technical and circumstantial factors. It is the sole responsibility of the user of this report to assess the applicability of the results and their interpretation. Authors The Distributed Systems Research Group is a part of the Department of Software Engineering, Faculty of Mathematics and Physics, Charles University, Prague, Czech Republic. The activities of the group include performance evaluation of CORBA broker platforms under the heading of the CORBA Comparison Project. The CORBA Comparison Project commenced in 1998 and has delivered output for partners such as MLC Systeme GmbH (now Deutsche Post Com GmbH), Iona Technologies, Borland International. The group also contributed to the OMG White Paper on Benchmarking. Confidential Page 2 Copyright 2003 Distributed Systems Research Group, Charles University

3 CORBA Comparison Project, Windows Visual C++ Platform Contents Contents... 3 Introduction... 4 Platform Configuration... 4 Measurement Technology... 4 Measurement Framework... 4 Acquiring Time Information... 4 Acquiring Resource Usage Information... 4 Measurement Results... 5 Time Distribution Graphs... 5 Time Pattern Graphs... 6 Box And Whiskers Graphs... 6 Resource Usage Graphs... 7 Initial... 8 Void... 8 Orbix TAO VisiBroker Summary Ping Orbix TAO VisiBroker Summary Invocation Static Invocation Orbix TAO VisiBroker Summary Dynamic Invocation Orbix TAO VisiBroker Summary Marshaling Marshaling Basic Types Orbix TAO VisiBroker Summary Marshaling Arrays Of Basic Types Orbix TAO VisiBroker Summary Marshaling Sequences Of Octets Orbix TAO VisiBroker Summary Dispatching Dispatching To Servant Instances Orbix TAO VisiBroker Summary Lifecycle Of Servant Instances Orbix TAO VisiBroker Summary Confidential Page 3 Copyright 2003 Distributed Systems Research Group, Charles University

4 CORBA Comparison Project, Windows Visual C++ Platform Introduction The purpose of this report is to present results of measurements that evaluate CORBA broker platforms along the three axes of response time, throughput and resource requirements. Platform Configuration The Windows Visual C++ platform was configured as follows: Dell Precision 340 Intel Pentium 4 2.2GHz 512MB RAM 100Mbit/s Full Duplex Ethernet Microsoft Windows 2000 Professional SP3 Microsoft Visual C SP5 The brokers tested were: Orbix 5.1 TAO VisiBroker 5.1 All suites except the Lifecycle Of Servant Instances suite were run remotely. The Lifecycle Of Servant Instances suite was run locally. This was necessary for correlating the timing information from the client with the timing information from the server. Measurement Technology Dedicated suites of tests measure individual aspects of broker performance. All suites employ the same measurement framework. To form a specific test, the framework is augmented by an action to be measured on the client side and servants to be instantiated on the server side. The concept of measurement framework is employed in both the C++ and Java environments. The implementations in both languages are functionally equivalent, except for short explicit garbage collection loop in Java client, which is aimed at ensuring similar starting conditions for each measurement. Measurement Framework The measurement framework carries out a measurement in five stages. Warm-up In the warm-up stage, the framework instantiates threads that carry out the action to be measured. When the threads start, the framework waits for a random time from 5 to 20 seconds to make sure the system is under a stable load before the measurement progresses. Client Resource Usage In the client resource usage stage, the framework collects information about client resource usage in 60 samples taken over the period of 60 seconds. For each resource, the minimum, maximum and average values are kept. Server Resource Usage In the server resource usage stage, the framework collects information about server resource usage, same as in the client resource usage stage. Solo Measurement In the solo measurement stage, the framework records 5000 individual measurements observed by a randomly selected thread. Information such as statistical distribution and quartiles is calculated from the individual measurements. Shared Measurement In the shared measurement stage, the framework records minimum, maximum and average values of measurements observed by all threads over the period of 60 seconds. Information such as overall minima, maxima and averages is calculated from the shared measurements. Each measurement is repeated 5 times. Acquiring Time Information Solaris On Solaris, the gethrtime() system call is used to obtain the time information. The resolution of thus obtained time is 1ns. Windows On Windows, the QueryPerformanceCounter() system call is used to obtain the time information. The resolution of thus obtained time is the same as the frequency of the processor clock. Acquiring Resource Usage Information Solaris The memory usage information on Solaris is collected from the /proc/self/psinfo file, where the resident and swapped application memory sizes are stored, from the kstat structures, where the kernel memory size is stored, from the sysconf() system call, which reports the total physical memory size, and from the swapctl() system call, which reports the total swapped memory size. The network usage information on Solaris is collected from the kstat structures, where the network traffic information is stored. The network usage information does not include the traffic over the loopback interface in bytes, which is not reported by the operating system. The processor usage information on Solaris is collected by hooking the thr_create() and pthread_create() system calls, where the application thread count is kept, and from the kstat structures, where the total processor usage is stored. Confidential Page 4 Copyright 2003 Distributed Systems Research Group, Charles University

5 CORBA Comparison Project, Windows Visual C++ Platform Windows On Windows, most information is collected from performance data accessible under HKEY_PERFORMANCE_DATA key in the registry. The data is not actually stored in the registry; the registry functions cause the system to collect the data from its source. The data come in form of performance objects, which represent various resources found in a system. Each object has a name and a set of named counters associated with it. The counters associated with an object can come in several instances for entities where it makes sense, e.g. processes, network interfaces, etc. The memory usage information is collected from Working Set and Page File Bytes counters of the corresponding instance of Process object, where the resident and swapped application memory sizes are stored, from Pool Paged Bytes and Pool Nonpaged Bytes counters of the Memory object, where the kernel memory sizes are stored and from the GlobalMemoryStatus() system call, which reports the total physical and total swapped memory sizes. The network usage information is collected from Bytes Sent/sec, Bytes Received/sec, Packets Sent/sec and Packets Received/sec counters of all instances of Network Interface object. The processor usage information is collected from Thread Count counter of the corresponding instance of Process object, where the application thread count is kept, and from % User Time, % Processor Time and % Privileged Time counters of all instances of Processor object, where the total processor usage is stored. Java In Java, the information is collected using native code methods contained in platform dependent dynamic shared libraries, which utilize the above-mentioned methods. The only exception is the application thread count, which is determined using pure Java methods and represents the number of active threads in the root thread group. Measurement Results Individual suites of tests are described in dedicated chapters. All chapters begin with a description of the suite accompanied by code fragments that characterize the suite. Except where not applicable, the interface definitions in IDL are present together with the code of the action to be measured on the client side and the code of the servants to be instantiated on the server side. The results of the tests follow the description in chapters dedicated to individual brokers and platforms. When more than one broker has been tested on a platform, a platform summary is also provided. The results are plotted in graphs accompanied by a description of what the graph shows. Time Distribution Graphs The time distribution graphs are calculated from data collected in the solo measurement stage. On the X axis are intervals of the time being measured, on the Y axis is the percentage of the measured times that fell within the given interval. The bars marked as other denote measured times that were either smaller or bigger than any of the intervals considered. Confidential Page 5 Copyright 2003 Distributed Systems Research Group, Charles University

6 CORBA Comparison Project, Windows Visual C++ Platform Time Pattern Graphs The time pattern graphs are calculated from data collected in the solo measurement stage. On the X axis is the sequential number of the measurement, on the Y axis is the measured time. Box And Whiskers Graphs The box and whiskers graphs are calculated from data collected in the solo measurement stage. The box spans from low to high quartile of the collected data and thus indicates the range within which half of the measured values fall. The whiskers span from minimum to maximum of the collected data and thus indicate the range within which all of the measured values fall. The median of the collected data is marked within the box. Confidential Page 6 Copyright 2003 Distributed Systems Research Group, Charles University

7 CORBA Comparison Project, Windows Visual C++ Platform Resource Usage Graphs The resource usage graphs are calculated from data collected in the client and server resource usage measurement stages. The solid line marks the average of the collected data. When present, a pair of dotted lines marks the minimum and maximum of the collected data. Confidential Page 7 Copyright 2003 Distributed Systems Research Group, Charles University

8 CORBA Comparison Project, Windows Visual C++ Platform Void Initial Void Description The suite measures an empty cycle of a constant length with a halfway timestamp. The purpose of the suite is to assess the impact of the measurement environment and measurement framework on the observed results. C++ Code ulonglong ActionVoid (void *pargs) { ulonglong itime; volatile int i; } // This is really just a cycle over a volatile variable to // waste some time and prevent too aggressive an optimization. for (i = 0 ; i < BEN_Cycles ; i ++) { }; itime = TIMGetTimestamp (); for (i = 0 ; i < BEN_Cycles ; i ++) { }; return (itime); Java Code public final void execute (long [] times) { for (int cntr = 0; cntr < BEN_Cycles; cntr++) { }; times [0] = SysInformer.timGetTimestamp (); for (int cntr = 0; cntr < BEN_Cycles; cntr++) { }; } Results The time distribution graphs should display a maximum for both the half cycle and the full cycle times. The maxima should be almost exclusive when a single thread is used and gradually less dominant when multiple threads are used. The most frequently observed time for the full cycle should be twice the most frequently observed time for the half cycle. The time pattern graphs should display a monotonous sequence for both the half cycle and the full cycle times, with a small number of regular fluctuations. The sequence should be gradually less uniform when multiple threads are used. The dependency of both the half cycle and the full cycle times on the number of threads should display constant minimum and median values and linearly increasing average and maximum values. The client thruput should be constant, except on multiprocessor systems, where the thruput should increase initially until the number of threads reaches the number of processors. The memory usage should be constant. The network usage should be zero. The thread usage should increase linearly on the client and be constant on the server. The processor usage should be monotonous and exclusively in user space. Confidential Page 8 Copyright 2003 Distributed Systems Research Group, Charles University

9 CORBA Comparison Project, Windows Visual C++ Platform Void/Orbix 5.1 Orbix 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Confidential Page 9 Copyright 2003 Distributed Systems Research Group, Charles University

10 CORBA Comparison Project, Windows Visual C++ Platform Void/Orbix 5.1 Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Confidential Page 10 Copyright 2003 Distributed Systems Research Group, Charles University

11 CORBA Comparison Project, Windows Visual C++ Platform Void/Orbix 5.1 Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the empty cycle on the number of threads running the cycle concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the cycle. Confidential Page 11 Copyright 2003 Distributed Systems Research Group, Charles University

12 CORBA Comparison Project, Windows Visual C++ Platform Void/Orbix 5.1 Confidential Page 12 Copyright 2003 Distributed Systems Research Group, Charles University

13 CORBA Comparison Project, Windows Visual C++ Platform Void/Orbix 5.1 Confidential Page 13 Copyright 2003 Distributed Systems Research Group, Charles University

14 CORBA Comparison Project, Windows Visual C++ Platform Void/TAO TAO Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Confidential Page 14 Copyright 2003 Distributed Systems Research Group, Charles University

15 CORBA Comparison Project, Windows Visual C++ Platform Void/TAO Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Confidential Page 15 Copyright 2003 Distributed Systems Research Group, Charles University

16 CORBA Comparison Project, Windows Visual C++ Platform Void/TAO Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the empty cycle on the number of threads running the cycle concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the cycle. Confidential Page 16 Copyright 2003 Distributed Systems Research Group, Charles University

17 CORBA Comparison Project, Windows Visual C++ Platform Void/TAO Confidential Page 17 Copyright 2003 Distributed Systems Research Group, Charles University

18 CORBA Comparison Project, Windows Visual C++ Platform Void/TAO Confidential Page 18 Copyright 2003 Distributed Systems Research Group, Charles University

19 CORBA Comparison Project, Windows Visual C++ Platform Void/VisiBroker 5.1 VisiBroker 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 19 Copyright 2003 Distributed Systems Research Group, Charles University

20 CORBA Comparison Project, Windows Visual C++ Platform Void/VisiBroker 5.1 Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the empty cycle on the number of threads running the cycle concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the cycle. Confidential Page 20 Copyright 2003 Distributed Systems Research Group, Charles University

21 CORBA Comparison Project, Windows Visual C++ Platform Void/VisiBroker 5.1 Confidential Page 21 Copyright 2003 Distributed Systems Research Group, Charles University

22 CORBA Comparison Project, Windows Visual C++ Platform Void/VisiBroker 5.1 Confidential Page 22 Copyright 2003 Distributed Systems Research Group, Charles University

23 CORBA Comparison Project, Windows Visual C++ Platform Void/Summary Summary Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the empty cycle. On the X axis are the time intervals, on the Y axis is the percentage of empty cycles completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Confidential Page 23 Copyright 2003 Distributed Systems Research Group, Charles University

24 CORBA Comparison Project, Windows Visual C++ Platform Void/Summary Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the empty cycle. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the cycle. Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the empty cycle on the number of threads running the cycle concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the cycle. Confidential Page 24 Copyright 2003 Distributed Systems Research Group, Charles University

25 CORBA Comparison Project, Windows Visual C++ Platform Void/Summary Confidential Page 25 Copyright 2003 Distributed Systems Research Group, Charles University

26 CORBA Comparison Project, Windows Visual C++ Platform Ping Ping Description The suite measures the time it takes to complete a trivial method invocation. The purpose of the suite is to assess the behavior of the broker on as simple an example as possible to minimize the chance of a systematic error. IDL Code interface Ping { void Pong (); } C++ Code ulonglong ActionPing (void *pargs) { pping->pong (); return (0); } void PingServant::Pong () { } Java Code public final void execute (long [] times) { pingserver.pong (); } public final void Pong () { } Results The time distribution graphs should display a cluster with small variance. The observed times should correspond with the observed times of other suites. The time pattern graphs should display a sequence with small variance. Confidential Page 26 Copyright 2003 Distributed Systems Research Group, Charles University

27 CORBA Comparison Project, Windows Visual C++ Platform Ping/Orbix 5.1 Orbix 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 27 Copyright 2003 Distributed Systems Research Group, Charles University

28 CORBA Comparison Project, Windows Visual C++ Platform Ping/Orbix 5.1 Evaluation The results exhibit no anomalies. Confidential Page 28 Copyright 2003 Distributed Systems Research Group, Charles University

29 CORBA Comparison Project, Windows Visual C++ Platform Ping/TAO TAO Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 29 Copyright 2003 Distributed Systems Research Group, Charles University

30 CORBA Comparison Project, Windows Visual C++ Platform Ping/TAO Evaluation The results exhibit no anomalies. Confidential Page 30 Copyright 2003 Distributed Systems Research Group, Charles University

31 CORBA Comparison Project, Windows Visual C++ Platform Ping/VisiBroker 5.1 VisiBroker 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 31 Copyright 2003 Distributed Systems Research Group, Charles University

32 CORBA Comparison Project, Windows Visual C++ Platform Ping/VisiBroker 5.1 Evaluation The results exhibit no anomalies. Confidential Page 32 Copyright 2003 Distributed Systems Research Group, Charles University

33 CORBA Comparison Project, Windows Visual C++ Platform Ping/Summary Summary Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Evaluation The results rate VisiBroker as the fastest broker in the scope measured by the suite, Orbix occupies the second and TAO the third place. Confidential Page 33 Copyright 2003 Distributed Systems Research Group, Charles University

34 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation Invocation Static Invocation Description The suite measures the time it takes to complete a static method invocation. The purpose of the suite is to assess the behavior of the static invocation mechanism. IDL Code interface Ping { ulonglong Pong (); } C++ Code ulonglong ActionPing (void *pargs) { return (pping->pong ()); } CORBA::ULongLong PingServant::Pong () { return (TIMGetTimestamp ()); } Java Code public final void execute (long [] times) { times [0] = pingserver.pong (); } public final long Pong () { return SysInformer.timGetTimestamp (); } Results The time distribution graphs should display clusters with small variance for both the halfway and the roundtrip times. The clusters should be gradually wider when multiple threads are used. The time pattern graphs should display a sequence with small variance for both the halfway and the roundtrip times. The sequence should be gradually less uniform when multiple threads are used. The dependency of both the halfway and the roundtrip times on the number of threads should display constant minimum values and at least linearly increasing median, average and maximum values. The increase over the linear dependency represents the overhead introduced by the concurrent execution. The client thruput should be constant or decreasing, except on multiprocessor systems, where the thruput should increase initially until the number of threads reaches the number of processors. The decrease under the constant level represents the overhead introduced by the concurrent execution. The memory usage should be constant or very slightly increasing. The network usage should be constant or very slightly decreasing. The thread usage should grow linearly on the client and reflect the threading model on the server. The processor usage should follow the thruput. Confidential Page 34 Copyright 2003 Distributed Systems Research Group, Charles University

35 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Orbix 5.1 Orbix 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 35 Copyright 2003 Distributed Systems Research Group, Charles University

36 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Orbix 5.1 Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 36 Copyright 2003 Distributed Systems Research Group, Charles University

37 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Orbix 5.1 Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 37 Copyright 2003 Distributed Systems Research Group, Charles University

38 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Orbix 5.1 Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 38 Copyright 2003 Distributed Systems Research Group, Charles University

39 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Orbix 5.1 Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 39 Copyright 2003 Distributed Systems Research Group, Charles University

40 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Orbix 5.1 Evaluation The roundtrip time for 1 thread corresponds with that of the Ping suite. The results indicate a slight decrease in thruput for a large number of threads. Confidential Page 40 Copyright 2003 Distributed Systems Research Group, Charles University

41 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/TAO TAO Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 41 Copyright 2003 Distributed Systems Research Group, Charles University

42 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/TAO Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 42 Copyright 2003 Distributed Systems Research Group, Charles University

43 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/TAO Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 43 Copyright 2003 Distributed Systems Research Group, Charles University

44 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/TAO Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 44 Copyright 2003 Distributed Systems Research Group, Charles University

45 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/TAO Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 45 Copyright 2003 Distributed Systems Research Group, Charles University

46 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/TAO Evaluation The roundtrip time for 1 thread corresponds with that of the Ping suite. The results indicate a significant decrease in thruput for a large number of threads. Confidential Page 46 Copyright 2003 Distributed Systems Research Group, Charles University

47 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/VisiBroker 5.1 VisiBroker 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 47 Copyright 2003 Distributed Systems Research Group, Charles University

48 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/VisiBroker 5.1 Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 48 Copyright 2003 Distributed Systems Research Group, Charles University

49 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/VisiBroker 5.1 Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 49 Copyright 2003 Distributed Systems Research Group, Charles University

50 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/VisiBroker 5.1 Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 50 Copyright 2003 Distributed Systems Research Group, Charles University

51 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/VisiBroker 5.1 Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 51 Copyright 2003 Distributed Systems Research Group, Charles University

52 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/VisiBroker 5.1 Evaluation The roundtrip time for 1 thread corresponds with that of the Ping suite. The results indicate a significant increase in client memory usage for a large number of threads. Confidential Page 52 Copyright 2003 Distributed Systems Research Group, Charles University

53 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Summary Summary Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 53 Copyright 2003 Distributed Systems Research Group, Charles University

54 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Summary Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Confidential Page 54 Copyright 2003 Distributed Systems Research Group, Charles University

55 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Summary Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 55 Copyright 2003 Distributed Systems Research Group, Charles University

56 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Summary Confidential Page 56 Copyright 2003 Distributed Systems Research Group, Charles University

57 CORBA Comparison Project, Windows Visual C++ Platform Static Invocation/Summary Evaluation The results rate VisiBroker as the fastest broker in the scope measured by the suite, Orbix occupies the second and TAO the third place. Orbix exhibits a slight decrease in thruput for a large number of threads. TAO exhibits a significant decrease in thruput for a large number of threads. VisiBroker exhibits a significant increase in client memory usage for a large number of threads. Confidential Page 57 Copyright 2003 Distributed Systems Research Group, Charles University

58 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation Dynamic Invocation Description The suite measures the time it takes to complete a dynamic method invocation. The purpose of the suite is to assess the behavior of the dynamic invocation mechanism. C++ Code ulonglong ActionPing (void *pargs) { CORBA::Request_var vrequest; CORBA::ULongLong iresult; vrequest = pping->_request ("Pong"); vrequest->set_return_type (CORBA::_tc_ulonglong); vrequest->invoke (ORBArgOnly); *(vrequest->result ()->value ()) >>= iresult; } return (iresult); void PingServant::invoke (CORBA::ServerRequest_ptr prequest) { if (!strcmp (prequest->operation (), "Pong")) { // Note that calling arguments is mandated by the // standard even when the function has none. } CORBA::NVList_ptr parguments; CORBA::Any oresult; porb->create_list (0, parguments); prequest->arguments (parguments); oresult <<= (CORBA::ULongLong) TIMGetTimestamp (); prequest->set_result (oresult); } else { assert (FALSE); } Java Code public final void execute (long [] times) { Request request = pingserver._request ("Pong"); request.set_return_type ( BenchBroker.theORB.get_primitive_tc (TCKind.tk_ulonglong)); request.invoke (); } times [0] = request.result ().value ().extract_ulonglong (); public final void invoke (ServerRequest request) { if (! request.operation ().equals ("Pong")) { throw new org.omg.corba.bad_operation (); } /* * Note that calling arguments is mandated by the * standard even when the function has none. */ org.omg.corba.nvlist args = BenchBroker.theORB.create_list (0); request.arguments (args); } org.omg.corba.any result = BenchBroker.theORB.create_any (); result.type ( BenchBroker.theORB.get_primitive_tc (TCKind.tk_ulonglong)); result.insert_ulonglong (SysInformer.timGetTimestamp ()); request.set_result (result); Confidential Page 58 Copyright 2003 Distributed Systems Research Group, Charles University

59 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation Results The time distribution graphs should display clusters with small variance for both the halfway and the roundtrip times. The clusters should be gradually wider when multiple threads are used. The time pattern graphs should display a sequence with small variance for both the halfway and the roundtrip times. The sequence should be gradually less uniform when multiple threads are used. The dependency of both the halfway and the roundtrip times on the number of threads should display constant minimum values and at least linearly increasing median, average and maximum values. The increase over the linear dependency represents the overhead introduced by the concurrent execution. The client thruput should be constant or decreasing, except on multiprocessor systems, where the thruput should increase initially until the number of threads reaches the number of processors. The decrease under the constant level represents the overhead introduced by the concurrent execution. The memory usage should be constant or very slightly increasing. The network usage should be constant or very slightly decreasing. The thread usage should grow linearly on the client and reflect the threading model on the server. The processor usage should follow the thruput. Confidential Page 59 Copyright 2003 Distributed Systems Research Group, Charles University

60 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Orbix 5.1 Orbix 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 60 Copyright 2003 Distributed Systems Research Group, Charles University

61 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Orbix 5.1 Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 61 Copyright 2003 Distributed Systems Research Group, Charles University

62 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Orbix 5.1 Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 62 Copyright 2003 Distributed Systems Research Group, Charles University

63 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Orbix 5.1 Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 63 Copyright 2003 Distributed Systems Research Group, Charles University

64 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Orbix 5.1 Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 64 Copyright 2003 Distributed Systems Research Group, Charles University

65 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Orbix 5.1 Evaluation The roundtrip time for 1 thread is slightly higher than that of the Ping suite. The results indicate a significant decrease in thruput for a large number of threads. Confidential Page 65 Copyright 2003 Distributed Systems Research Group, Charles University

66 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/TAO TAO Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 66 Copyright 2003 Distributed Systems Research Group, Charles University

67 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/TAO Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 67 Copyright 2003 Distributed Systems Research Group, Charles University

68 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/TAO Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 68 Copyright 2003 Distributed Systems Research Group, Charles University

69 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/TAO Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 69 Copyright 2003 Distributed Systems Research Group, Charles University

70 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/TAO Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 70 Copyright 2003 Distributed Systems Research Group, Charles University

71 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/TAO Evaluation The roundtrip time for 1 thread is slightly higher than that of the Ping suite. The results indicate a slight decrease in thruput for a large number of threads. Confidential Page 71 Copyright 2003 Distributed Systems Research Group, Charles University

72 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/VisiBroker 5.1 VisiBroker 5.1 Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 72 Copyright 2003 Distributed Systems Research Group, Charles University

73 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/VisiBroker 5.1 Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 73 Copyright 2003 Distributed Systems Research Group, Charles University

74 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/VisiBroker 5.1 Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 74 Copyright 2003 Distributed Systems Research Group, Charles University

75 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/VisiBroker 5.1 Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (100 Threads, Zoom) The graph is a zoom in of the previous graph. Confidential Page 75 Copyright 2003 Distributed Systems Research Group, Charles University

76 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/VisiBroker 5.1 Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 76 Copyright 2003 Distributed Systems Research Group, Charles University

77 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/VisiBroker 5.1 Evaluation The roundtrip time for 1 thread is slightly higher than that of the Ping suite. The results indicate a slight decrease in thruput for a large number of threads and a significant increase in client memory usage for a large number of threads. Confidential Page 77 Copyright 2003 Distributed Systems Research Group, Charles University

78 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Summary Summary Time Distribution (1 Thread) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (10 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Time Distribution (100 Threads) The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval. Confidential Page 78 Copyright 2003 Distributed Systems Research Group, Charles University

79 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Summary Time Pattern (1 Thread) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Time Pattern (10 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Confidential Page 79 Copyright 2003 Distributed Systems Research Group, Charles University

80 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Summary Time Pattern (100 Threads) The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation. Dependency On Number Of Threads The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation. Confidential Page 80 Copyright 2003 Distributed Systems Research Group, Charles University

81 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Summary Confidential Page 81 Copyright 2003 Distributed Systems Research Group, Charles University

82 CORBA Comparison Project, Windows Visual C++ Platform Dynamic Invocation/Summary Evaluation The results rate VisiBroker as the fastest broker in the scope measured by the suite, Orbix occupies the second and TAO the third place. Orbix exhibits a significant decrease in thruput for a large number of threads. TAO exhibits a slight decrease in thruput for a large number of threads. VisiBroker exhibits a slight decrease in thruput and a significant increase in client memory usage for a large number of threads. Confidential Page 82 Copyright 2003 Distributed Systems Research Group, Charles University

83 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types Marshaling Marshaling Basic Types Description The suite measures the time it takes to complete a method invocation depending on the type and direction of the argument. The purpose of the suite is to assess the behavior of the marshaling mechanism. Direction IN IDL Code typedef <type> tpingarg; interface Ping { void Pong (in tpingarg xarg); } C++ Code tpingarg xpingarg; ulonglong ActionPing (void *pargs) { pping->pong (xpingarg); return (0); } void PingServant::Pong (tpingarg xarg) { } Java Code private <type> pingarg; public final void execute (long [] times) { pingserver.pong (pingarg); } public final void Pong (<type> xarg) { } Direction OUT IDL Code typedef <type> tpingarg; interface Ping { void Pong (out tpingarg xarg); } C++ Code tpingarg xpingarg; ulonglong ActionPing (void *pargs) { pping->pong (xpingarg); return (0); } void PingServant::Pong (tpingarg_out xarg) { } Java Code private <type> pingarg; public final void execute (long [] times) { pingserver.pong (pingarg); } public final void Pong (<type> xarg) { } Direction INOUT IDL Code typedef <type> tpingarg; interface Ping { void Pong (inout tpingarg xarg); } C++ Code Confidential Page 83 Copyright 2003 Distributed Systems Research Group, Charles University

84 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types tpingarg xpingarg; ulonglong ActionPing (void *pargs) { pping->pong (xpingarg); return (0); } void PingServant::Pong (tpingarg &xarg) { } Java Code private <type> pingarg; public final void execute (long [] times) { pingserver.pong (pingarg); } public final void Pong (<type> xarg) { } Direction RETURN IDL Code typedef <type> tpingarg; interface Ping { tpingarg Pong (); } C++ Code ulonglong ActionPing (void *pargs) { pping->pong (); return (0); } tpingarg xpingarg; tpingarg PingServant::Pong () { return (xpingarg); } Java Code public final void execute (long [] times) { pingserver.pong (); } private <type> pingarg; public final <type> Pong () { return (pingarg); } Results The roundtrip time should be constant for all the types and directions of the argument, except for the char and wchar types, where the roundtrip time may be affected by the character set conversion, and the long long, unsigned long long and long double types, where the roundtrip time may be affected by the handling of non native types. The quartile range of the values should be small. The memory usage, network usage and processor usage should be constant, except for the char and wchar types, where the usage may be affected by the character set conversion, and the long long, unsigned long long and long double types, where the usage may be affected by the handling of non native types. Confidential Page 84 Copyright 2003 Distributed Systems Research Group, Charles University

85 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Orbix 5.1 Orbix 5.1 Dependency On Type (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 85 Copyright 2003 Distributed Systems Research Group, Charles University

86 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Orbix 5.1 Dependency On Type (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 86 Copyright 2003 Distributed Systems Research Group, Charles University

87 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Orbix 5.1 Dependency On Type (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 87 Copyright 2003 Distributed Systems Research Group, Charles University

88 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Orbix 5.1 Dependency On Type (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 88 Copyright 2003 Distributed Systems Research Group, Charles University

89 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Orbix 5.1 Notes The broker does not support the long double type. Evaluation The roundtrip times correspond with that of the Ping suite. The results exhibit no anomalies. Confidential Page 89 Copyright 2003 Distributed Systems Research Group, Charles University

90 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/TAO TAO Dependency On Type (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 90 Copyright 2003 Distributed Systems Research Group, Charles University

91 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/TAO Dependency On Type (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 91 Copyright 2003 Distributed Systems Research Group, Charles University

92 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/TAO Confidential Page 92 Copyright 2003 Distributed Systems Research Group, Charles University

93 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/TAO Dependency On Type (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 93 Copyright 2003 Distributed Systems Research Group, Charles University

94 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/TAO Dependency On Type (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 94 Copyright 2003 Distributed Systems Research Group, Charles University

95 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/TAO Evaluation The roundtrip times correspond with that of the Ping suite. The results exhibit no anomalies. Confidential Page 95 Copyright 2003 Distributed Systems Research Group, Charles University

96 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/VisiBroker 5.1 VisiBroker 5.1 Dependency On Type (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 96 Copyright 2003 Distributed Systems Research Group, Charles University

97 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/VisiBroker 5.1 Dependency On Type (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 97 Copyright 2003 Distributed Systems Research Group, Charles University

98 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/VisiBroker 5.1 Dependency On Type (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 98 Copyright 2003 Distributed Systems Research Group, Charles University

99 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/VisiBroker 5.1 Dependency On Type (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 99 Copyright 2003 Distributed Systems Research Group, Charles University

100 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/VisiBroker 5.1 Notes The broker does not support the long double type. Evaluation The roundtrip times correspond with that of the Ping suite. The results exhibit no anomalies. Confidential Page 100 Copyright 2003 Distributed Systems Research Group, Charles University

101 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Summary Dependency On Type (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 101 Copyright 2003 Distributed Systems Research Group, Charles University

102 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Confidential Page 102 Copyright 2003 Distributed Systems Research Group, Charles University

103 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Dependency On Type (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 103 Copyright 2003 Distributed Systems Research Group, Charles University

104 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Confidential Page 104 Copyright 2003 Distributed Systems Research Group, Charles University

105 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Dependency On Type (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 105 Copyright 2003 Distributed Systems Research Group, Charles University

106 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Confidential Page 106 Copyright 2003 Distributed Systems Research Group, Charles University

107 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Dependency On Type (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 107 Copyright 2003 Distributed Systems Research Group, Charles University

108 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Confidential Page 108 Copyright 2003 Distributed Systems Research Group, Charles University

109 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Basic Types/Summary Notes Orbix and VisiBroker do not support the long double type. Evaluation The results rate VisiBroker as the fastest broker in the scope measured by the suite, Orbix occupies the second and TAO the third place. Confidential Page 109 Copyright 2003 Distributed Systems Research Group, Charles University

110 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types Marshaling Arrays Of Basic Types Description The suite measures the time it takes to complete a method invocation depending on the type and direction of the argument. The purpose of the suite is to assess the behavior of the marshaling mechanism. Direction IN IDL Code typedef <type> tpingarg [<size>]; interface Ping { void Pong (in tpingarg xarg); } C++ Code tpingarg xpingarg; ulonglong ActionPing (void *pargs) { pping->pong (xpingarg); return (0); } void PingServant::Pong (const tpingarg xarg) { } Java Code private tpingargholder pingarg; public final void execute (long [] times) { pingserver.pong (pingarg.value); } public final void Pong (<type> [] xarg) { } Direction OUT IDL Code typedef <type> tpingarg [<size>]; interface Ping { void Pong (out tpingarg xarg); } C++ Code tpingarg xpingarg; ulonglong ActionPing (void *pargs) { pping->pong (xpingarg); return (0); } void PingServant::Pong (tpingarg_out xarg) { } Java Code private tpingargholder pingarg; public final void execute (long [] times) { pingserver.pong (pingarg); pingarg.value = null; } private <type> [] pingarg = new <type> [<size>]; public final void Pong (tpingargholder xarg) { xarg.value = pingarg; } Direction INOUT IDL Code typedef <type> tpingarg [<size>]; interface Ping { void Pong (inout tpingarg xarg); } C++ Code Confidential Page 110 Copyright 2003 Distributed Systems Research Group, Charles University

111 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types tpingarg xpingarg; ulonglong ActionPing (void *pargs) { pping->pong (xpingarg); return (0); } void PingServant::Pong (tpingarg &xarg) { } Java Code private tpingargholder pingarg; public final void execute (long [] times) { pingserver.pong (pingarg); } public final void Pong (tpingargholder xarg) { } Direction RETURN IDL Code typedef <type> tpingarg [<size>]; interface Ping { tpingarg Pong (); } C++ Code ulonglong ActionPing (void *pargs) { tpingarg_free (pping->pong ()); return (0); } tpingarg_slice *PingServant::Pong () { return (tpingarg_alloc ()); } Java Code public final void execute (long [] times) { pingserver.pong (); } private <type> [] pingarg = new <type> [<size>]; public final <type> [] Pong () { return pingarg; } Results The roundtrip time should depend predominantly on the total size of the argument for all the types and directions of the argument, except for the char and wchar types, where the roundtrip time may be affected by the character set conversion, and the long long, unsigned long long and long double types, where the roundtrip time may be affected by the handling of non native types. The quartile range of the values should be small. The memory usage, network usage and processor usage should depend predominantly on the total size of the argument, except for the char and wchar types, where the usage may be affected by the character set conversion, and the long long, unsigned long long and long double types, where the usage may be affected by the handling of non native types. Confidential Page 111 Copyright 2003 Distributed Systems Research Group, Charles University

112 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Orbix 5.1 Dependency On Type (Direction IN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 112 Copyright 2003 Distributed Systems Research Group, Charles University

113 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction OUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 113 Copyright 2003 Distributed Systems Research Group, Charles University

114 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction INOUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 114 Copyright 2003 Distributed Systems Research Group, Charles University

115 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction RETURN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 115 Copyright 2003 Distributed Systems Research Group, Charles University

116 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction IN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 116 Copyright 2003 Distributed Systems Research Group, Charles University

117 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction OUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 117 Copyright 2003 Distributed Systems Research Group, Charles University

118 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction INOUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 118 Copyright 2003 Distributed Systems Research Group, Charles University

119 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Dependency On Type (Direction RETURN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 119 Copyright 2003 Distributed Systems Research Group, Charles University

120 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Orbix 5.1 Notes The broker does not support the long double type. Evaluation The results indicate a significant overhead of the character set conversion for the wchar type. Confidential Page 120 Copyright 2003 Distributed Systems Research Group, Charles University

121 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO TAO Dependency On Type (Direction IN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 121 Copyright 2003 Distributed Systems Research Group, Charles University

122 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction OUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 122 Copyright 2003 Distributed Systems Research Group, Charles University

123 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Confidential Page 123 Copyright 2003 Distributed Systems Research Group, Charles University

124 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction INOUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 124 Copyright 2003 Distributed Systems Research Group, Charles University

125 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction RETURN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 125 Copyright 2003 Distributed Systems Research Group, Charles University

126 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction IN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 126 Copyright 2003 Distributed Systems Research Group, Charles University

127 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction OUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 127 Copyright 2003 Distributed Systems Research Group, Charles University

128 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction INOUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 128 Copyright 2003 Distributed Systems Research Group, Charles University

129 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Dependency On Type (Direction RETURN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 129 Copyright 2003 Distributed Systems Research Group, Charles University

130 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/TAO Evaluation The results exhibit no anomalies. Confidential Page 130 Copyright 2003 Distributed Systems Research Group, Charles University

131 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 VisiBroker 5.1 Dependency On Type (Direction IN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 131 Copyright 2003 Distributed Systems Research Group, Charles University

132 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction OUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 132 Copyright 2003 Distributed Systems Research Group, Charles University

133 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction INOUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 133 Copyright 2003 Distributed Systems Research Group, Charles University

134 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction RETURN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 134 Copyright 2003 Distributed Systems Research Group, Charles University

135 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction IN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 135 Copyright 2003 Distributed Systems Research Group, Charles University

136 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction OUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 136 Copyright 2003 Distributed Systems Research Group, Charles University

137 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction INOUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 137 Copyright 2003 Distributed Systems Research Group, Charles University

138 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Dependency On Type (Direction RETURN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 138 Copyright 2003 Distributed Systems Research Group, Charles University

139 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/VisiBroker 5.1 Notes The broker does not support the long double type. Evaluation The results indicate a significant overhead of the character set conversion for the wchar type. Confidential Page 139 Copyright 2003 Distributed Systems Research Group, Charles University

140 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Summary Dependency On Type (Direction IN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 140 Copyright 2003 Distributed Systems Research Group, Charles University

141 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 141 Copyright 2003 Distributed Systems Research Group, Charles University

142 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction OUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 142 Copyright 2003 Distributed Systems Research Group, Charles University

143 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 143 Copyright 2003 Distributed Systems Research Group, Charles University

144 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction INOUT, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 144 Copyright 2003 Distributed Systems Research Group, Charles University

145 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 145 Copyright 2003 Distributed Systems Research Group, Charles University

146 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction RETURN, 1024 Octets, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 146 Copyright 2003 Distributed Systems Research Group, Charles University

147 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 147 Copyright 2003 Distributed Systems Research Group, Charles University

148 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction IN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 148 Copyright 2003 Distributed Systems Research Group, Charles University

149 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 149 Copyright 2003 Distributed Systems Research Group, Charles University

150 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction OUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 150 Copyright 2003 Distributed Systems Research Group, Charles University

151 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 151 Copyright 2003 Distributed Systems Research Group, Charles University

152 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction INOUT, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 152 Copyright 2003 Distributed Systems Research Group, Charles University

153 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 153 Copyright 2003 Distributed Systems Research Group, Charles University

154 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Dependency On Type (Direction RETURN, 1024 Items, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the type and direction of the argument. On the X axis is the type of the argument, on the Y axis is the time it took to complete the invocation. Confidential Page 154 Copyright 2003 Distributed Systems Research Group, Charles University

155 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Confidential Page 155 Copyright 2003 Distributed Systems Research Group, Charles University

156 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Arrays Of Basic Types/Summary Notes Orbix and VisiBroker do not support the long double type. Evaluation The results rate VisiBroker as the fastest broker in the scope measured by the suite, Orbix occupies the second and TAO the third place. Orbix exhibits a significant overhead of the character set conversion for the wchar type. VisiBroker exhibits a significant overhead of the character set conversion for the wchar type. Confidential Page 156 Copyright 2003 Distributed Systems Research Group, Charles University

157 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets Marshaling Sequences Of Octets Description The suite measures the time it takes to complete a method invocation depending on the size of the octet sequence passed as argument. The purpose of the suite is to assess the behavior of the marshaling mechanism. Direction IN IDL Code typedef sequence<octet> toctetsequence; interface Ping { void Pong (in toctetsequence ssequence); } C++ Code toctetsequence *ppingoctetsequence; ulonglong ActionPing (void *pargs) { pping->pong (*ppingoctetsequence); } void PingServant::Pong (const toctetsequence &ssequence) { } Java Code private toctetsequenceholder sequenceholder; public final void execute (long [] times) { pingserver.pong (sequenceholder.value); } public final void Pong (byte [] ssequence) { } Direction OUT IDL Code typedef sequence<octet> toctetsequence; interface Ping { void Pong (in unsigned long ilength, out toctetsequence ssequence); } C++ Code toctetsequence *ppingoctetsequence; CORBA::ULong ipingoctetsequencelength; ulonglong ActionPing (void *pargs) { pping->pong (ipingoctetsequencelength, ppingoctetsequence); delete (ppingoctetsequence); } void PingServant::Pong (CORBA::ULong ilength, toctetsequence_out psequence) { psequence = new toctetsequence (ilength); psequence->length (ilength); } Java Code public static int sequencelength; private toctetsequenceholder sequenceholder; public final void execute (long [] times) { pingserver.pong (sequencelength, sequenceholder); sequenceholder.value = null; } public final void Pong (int ilength, toctetsequenceholder ssequence) { ssequence.value = new byte [ilength]; } Confidential Page 157 Copyright 2003 Distributed Systems Research Group, Charles University

158 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets Direction INOUT IDL Code typedef sequence<octet> toctetsequence; interface Ping { void Pong (inout toctetsequence ssequence); } C++ Code toctetsequence *ppingoctetsequence; ulonglong ActionPing (void *pargs) { pping->pong (*ppingoctetsequence); } void PingServant::Pong (toctetsequence &ssequence) { } Java Code private toctetsequenceholder sequenceholder; public final void execute (long [] times) { pingserver.pong (sequenceholder); } public final void Pong (toctetsequenceholder ssequence) { } Direction RETURN IDL Code typedef sequence<octet> toctetsequence; interface Ping { toctetsequence Pong (in unsigned long ilength); } C++ Code CORBA::ULong ipingoctetsequencelength; ulonglong ActionPing (void *pargs) { delete (pping->pong (ipingoctetsequencelength); } toctetsequence *PingServant::Pong (CORBA::ULong ilength) { toctetsequence *psequence; psequence = new toctetsequence (ilength); psequence->length (ilength); return (psequence); } Java Code public static int sequencelength; public final void execute (long [] times) { pingserver.pong (sequencelength); } public final byte [] Pong (int ilength) { return new byte [ilength]; } Results The dependency of the roundtrip time on the size of the sequence should display linearly increasing minimum, median and average values and reasonably small maximum values. The memory usage should be constant or very slightly increasing. The network usage should be asymptotically increasing towards the maximum capacity. The processor usage should follow the network usage. Confidential Page 158 Copyright 2003 Distributed Systems Research Group, Charles University

159 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Orbix 5.1 Orbix 5.1 Dependency On Size Of Sequence (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 159 Copyright 2003 Distributed Systems Research Group, Charles University

160 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Orbix 5.1 Dependency On Size Of Sequence (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 160 Copyright 2003 Distributed Systems Research Group, Charles University

161 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Orbix 5.1 Dependency On Size Of Sequence (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 161 Copyright 2003 Distributed Systems Research Group, Charles University

162 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Orbix 5.1 Confidential Page 162 Copyright 2003 Distributed Systems Research Group, Charles University

163 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Orbix 5.1 Dependency On Size Of Sequence (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 163 Copyright 2003 Distributed Systems Research Group, Charles University

164 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Orbix 5.1 Evaluation The roundtrip time for 1 octet sequence corresponds with that of the Ping suite. The results exhibit no anomalies. Confidential Page 164 Copyright 2003 Distributed Systems Research Group, Charles University

165 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/TAO TAO Dependency On Size Of Sequence (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 165 Copyright 2003 Distributed Systems Research Group, Charles University

166 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/TAO Dependency On Size Of Sequence (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 166 Copyright 2003 Distributed Systems Research Group, Charles University

167 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/TAO Dependency On Size Of Sequence (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 167 Copyright 2003 Distributed Systems Research Group, Charles University

168 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/TAO Confidential Page 168 Copyright 2003 Distributed Systems Research Group, Charles University

169 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/TAO Dependency On Size Of Sequence (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 169 Copyright 2003 Distributed Systems Research Group, Charles University

170 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/TAO Evaluation The roundtrip time for 1 octet sequence corresponds with that of the Ping suite. The results exhibit no anomalies. Confidential Page 170 Copyright 2003 Distributed Systems Research Group, Charles University

171 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/VisiBroker 5.1 VisiBroker 5.1 Dependency On Size Of Sequence (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 171 Copyright 2003 Distributed Systems Research Group, Charles University

172 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/VisiBroker 5.1 Dependency On Size Of Sequence (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 172 Copyright 2003 Distributed Systems Research Group, Charles University

173 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/VisiBroker 5.1 Dependency On Size Of Sequence (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 173 Copyright 2003 Distributed Systems Research Group, Charles University

174 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/VisiBroker 5.1 Confidential Page 174 Copyright 2003 Distributed Systems Research Group, Charles University

175 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/VisiBroker 5.1 Dependency On Size Of Sequence (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 175 Copyright 2003 Distributed Systems Research Group, Charles University

176 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/VisiBroker 5.1 Evaluation The roundtrip time for 1 octet sequence corresponds with that of the Ping suite. The results exhibit no anomalies. Confidential Page 176 Copyright 2003 Distributed Systems Research Group, Charles University

177 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Summary Dependency On Size Of Sequence (Direction IN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 177 Copyright 2003 Distributed Systems Research Group, Charles University

178 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Dependency On Size Of Sequence (Direction OUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 178 Copyright 2003 Distributed Systems Research Group, Charles University

179 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Confidential Page 179 Copyright 2003 Distributed Systems Research Group, Charles University

180 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Dependency On Size Of Sequence (Direction INOUT, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 180 Copyright 2003 Distributed Systems Research Group, Charles University

181 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Confidential Page 181 Copyright 2003 Distributed Systems Research Group, Charles University

182 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Dependency On Size Of Sequence (Direction RETURN, 1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the size of the octet sequence passed as argument. On the X axis is the size of the sequence, on the Y axis is the time it took to complete the invocation. Confidential Page 182 Copyright 2003 Distributed Systems Research Group, Charles University

183 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Confidential Page 183 Copyright 2003 Distributed Systems Research Group, Charles University

184 CORBA Comparison Project, Windows Visual C++ Platform Marshaling Sequences Of Octets/Summary Evaluation The results rate Orbix, TAO and VisiBroker as of the same speed in the scope measured by the suite. Orbix, TAO and VisiBroker exhibit the same shape of dependency on the size of sequence. Confidential Page 184 Copyright 2003 Distributed Systems Research Group, Charles University

185 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances Dispatching Dispatching To Servant Instances Description The suite measures the time it takes to complete a method invocation depending on the number of active servants hosted by the server. The purpose of the suite is to assess the behavior of the dispatching mechanism. IDL Code interface Ping { void Pong (); } typedef sequence<ping> tpingsequence; C++ Code tpingsequence *ppingsequence; CORBA::ULong ipingsequencelength; ulonglong ActionPing (void *pargs) { (*ppingsequence) [RNDGetRandom (ipingsequencelength)]->pong (); return (0); } void PingServant::Pong () { } Java Code public static int pingsequencelength; public static Ping [] pingsequence; public final void execute (long [] times) { pingsequence [(int) BenchGlobal.rand (pingsequencelength)].pong (); } public final void Pong () { } Results The dependency of the roundtrip time on the number of servants should display constant or less than linearly increasing minimum, median and average values and reasonably small maximum values. The memory usage should be linearly increasing and reflect the size of the servants on the server and the proxies on the client. The network usage should be constant or very slightly decreasing. The processor usage should be monotonous. Confidential Page 185 Copyright 2003 Distributed Systems Research Group, Charles University

186 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Orbix 5.1 Orbix 5.1 Dependency On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the number of active servants hosted by the server. On the X axis is the number of servants, on the Y axis is the time it took to complete the invocation. Confidential Page 186 Copyright 2003 Distributed Systems Research Group, Charles University

187 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Orbix 5.1 Dependency On Number Of Servants (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 187 Copyright 2003 Distributed Systems Research Group, Charles University

188 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Orbix 5.1 Evaluation The roundtrip time for 1 servant instance corresponds with that of the Ping suite. The results indicate a slight increase in the invocation time for a large number of servants. The memory usage observed during the test is roughly 330 bytes per servant instance on the server and roughly 450 bytes per proxy instance on the client. Confidential Page 188 Copyright 2003 Distributed Systems Research Group, Charles University

189 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/TAO TAO Dependency On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the number of active servants hosted by the server. On the X axis is the number of servants, on the Y axis is the time it took to complete the invocation. Confidential Page 189 Copyright 2003 Distributed Systems Research Group, Charles University

190 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/TAO Dependency On Number Of Servants (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 190 Copyright 2003 Distributed Systems Research Group, Charles University

191 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/TAO Evaluation The roundtrip time for 1 servant instance corresponds with that of the Ping suite. The results exhibit no anomalies. The memory usage observed during the test is roughly 1300 bytes per servant instance on the server and roughly 1400 bytes per proxy instance on the client. Confidential Page 191 Copyright 2003 Distributed Systems Research Group, Charles University

192 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/VisiBroker 5.1 VisiBroker 5.1 Dependency On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the number of active servants hosted by the server. On the X axis is the number of servants, on the Y axis is the time it took to complete the invocation. Confidential Page 192 Copyright 2003 Distributed Systems Research Group, Charles University

193 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/VisiBroker 5.1 Dependency On Number Of Servants (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 193 Copyright 2003 Distributed Systems Research Group, Charles University

194 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/VisiBroker 5.1 Evaluation The roundtrip time for 1 servant instance corresponds with that of the Ping suite. The results indicate a significant increase in the invocation time for a large number of servants. The memory usage observed during the test is roughly 2400 bytes per servant instance on the server and roughly 5000 bytes per proxy instance on the client. Confidential Page 194 Copyright 2003 Distributed Systems Research Group, Charles University

195 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Summary Summary Dependency On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to complete the invocation on the number of active servants hosted by the server. On the X axis is the number of servants, on the Y axis is the time it took to complete the invocation. Confidential Page 195 Copyright 2003 Distributed Systems Research Group, Charles University

196 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Summary Dependency On Number Of Servants (1 Thread, Zoom) The graph is a zoom in of the previous graph. Confidential Page 196 Copyright 2003 Distributed Systems Research Group, Charles University

197 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Summary Confidential Page 197 Copyright 2003 Distributed Systems Research Group, Charles University

198 CORBA Comparison Project, Windows Visual C++ Platform Dispatching To Servant Instances/Summary Evaluation The results rate Orbix as the fastest broker in the scope measured by the suite, TAO occupies the second and VisiBroker the third place. For a small number of objects, VisiBroker rates as the fastest broker, Orbix occupies the second and TAO the third place. Orbix and TAO exhibit the best shape of dependency on the number of servants, VisiBroker occupies the second place. Orbix exhibits the smallest memory usage, TAO occupies the second and VisiBroker the third place. Confidential Page 198 Copyright 2003 Distributed Systems Research Group, Charles University

199 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances Lifecycle Of Servant Instances Description The suite measures the time it takes to create and delete a servant and to create and delete a proxy depending on the number of active servants hosted by the server and active proxies hosted by the client. The purpose of the suite is to assess the behavior of the servant lifecycle mechanism. IDL Code interface Empty { }; typedef sequence<empty> temptysequence; interface EmptyFactory { void CreateIndividual (out Empty oempty, out unsigned long long itimeinvoke, out unsigned long long itimereturn); void DeleteIndividual (in Empty oempty, out unsigned long long itimeinvoke, out unsigned long long itimereturn); temptysequence CreateSequence (in unsigned long ilength); }; C++ Code temptyfactory *pemptyfactory; void ActionCreateDelete (tmeaargs *pargs) { Empty_ptr pempty; pemptyfactory->createindividual (pempty, pargs->aitimes [BEN_StampCreateInvoke], pargs->aitimes [BEN_StampCreateReturn]); pargs->aitimes [BEN_StampCreateFinish] = TIMGetTimestamp (); pemptyfactory->deleteindividual (pempty, pargs->aitimes [BEN_StampDeleteInvoke], pargs->aitimes [BEN_StampDeleteReturn]); CORBA::release (pempty); pargs->aitimes [BEN_StampDeleteFinish] = TIMGetTimestamp (); } void EmptyFactoryServant::CreateIndividual ( Empty_out pempty, CORBA::ULongLong_out itimeinvoke, CORBA::ULongLong_out itimereturn) { itimeinvoke = TIMGetTimestamp (); EmptyServant *pemptyservant = new EmptyServant (); pempty = pemptyservant->_this (); itimereturn = TIMGetTimestamp (); } void EmptyFactoryServant::DeleteIndividual ( Empty_ptr pempty, CORBA::ULongLong_out itimeinvoke, CORBA::ULongLong_out itimereturn) { itimeinvoke = TIMGetTimestamp (); PortableServer::ObjectId_var vemptyoid = prootpoa->reference_to_id (pempty); PortableServer::ServantBase *pemptyservant = prootpoa->reference_to_servant (pempty); prootpoa->deactivate_object (vemptyoid); delete (pemptyservant); itimereturn = TIMGetTimestamp (); } Java Code public static int emptysequencelength; public static Empty [] emptysequence; public static EmptyFactory emptyfactory; private LongHolder invokestamp = new LongHolder (); private LongHolder returnstamp = new LongHolder (); private EmptyHolder emptyholder = new EmptyHolder (); public final void execute (long [] times) { Confidential Page 199 Copyright 2003 Distributed Systems Research Group, Charles University

200 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances emptyfactory.createindividual (emptyholder, invokestamp, returnstamp); times [BEN_StampCreateFinish] = SysInformer.timGetTimestamp (); times [BEN_StampCreateInvoke] = invokestamp.value; times [BEN_StampCreateReturn] = returnstamp.value; emptyfactory.deleteindividual (emptyholder.value, invokestamp, returnstamp); times [BEN_StampDeleteFinish] = SysInformer.timGetTimestamp (); times [BEN_StampDeleteInvoke] = invokestamp.value; times [BEN_StampDeleteReturn] = returnstamp.value; } emptyholder.value = null; public final void CreateIndividual ( EmptyHolder oempty, LongHolder itimeinvoke, LongHolder itimereturn) { } itimeinvoke.value = SysInformer.timGetTimestamp (); EmptyServant emptyservant = new EmptyServant (); oempty.value = EmptyHelper.narrow ( BenchBroker.rootPOA.servant_to_reference (emptyservant)); itimereturn.value = SysInformer.timGetTimestamp (); public final void DeleteIndividual ( Empty oempty, LongHolder itimeinvoke, LongHolder itimereturn) { } itimeinvoke.value = SysInformer.timGetTimestamp (); byte [] emptyoid = BenchBroker.rootPOA.reference_to_id (oempty); BenchBroker.rootPOA.deactivate_object (emptyoid); itimereturn.value = SysInformer.timGetTimestamp (); Results The dependency of the create and the delete times on the number of servants should display constant or less than linearly increasing minimum, median and average values and reasonably small maximum values. The memory usage should be linearly increasing and reflect the size of the servants on the server and the proxies on the client. The network usage should be constant or very slightly decreasing. The processor usage should be monotonous. Confidential Page 200 Copyright 2003 Distributed Systems Research Group, Charles University

201 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Orbix 5.1 Orbix 5.1 Dependency Of Create On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 201 Copyright 2003 Distributed Systems Research Group, Charles University

202 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Orbix 5.1 Dependency Of Create On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 202 Copyright 2003 Distributed Systems Research Group, Charles University

203 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Orbix 5.1 Dependency Of Delete On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 203 Copyright 2003 Distributed Systems Research Group, Charles University

204 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Orbix 5.1 Dependency Of Delete On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 204 Copyright 2003 Distributed Systems Research Group, Charles University

205 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Orbix 5.1 Evaluation The results indicate a significant increase in the create and delete times for a large number of servants. The memory usage observed during the test is roughly 330 bytes per servant instance on the server and roughly 430 bytes per proxy instance on the client. Confidential Page 205 Copyright 2003 Distributed Systems Research Group, Charles University

206 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/TAO TAO Dependency Of Create On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 206 Copyright 2003 Distributed Systems Research Group, Charles University

207 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/TAO Dependency Of Create On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 207 Copyright 2003 Distributed Systems Research Group, Charles University

208 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/TAO Dependency Of Delete On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 208 Copyright 2003 Distributed Systems Research Group, Charles University

209 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/TAO Dependency Of Delete On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 209 Copyright 2003 Distributed Systems Research Group, Charles University

210 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/TAO Evaluation The results indicate a significant increase in the create time and slight increase in the delete time for a large number of servants. The memory usage observed during the test is roughly 1200 bytes per servant instance on the server and roughly 1400 bytes per proxy instance on the client. Confidential Page 210 Copyright 2003 Distributed Systems Research Group, Charles University

211 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/VisiBroker 5.1 VisiBroker 5.1 Dependency Of Create On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 211 Copyright 2003 Distributed Systems Research Group, Charles University

212 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/VisiBroker 5.1 Dependency Of Create On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 212 Copyright 2003 Distributed Systems Research Group, Charles University

213 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/VisiBroker 5.1 Dependency Of Delete On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 213 Copyright 2003 Distributed Systems Research Group, Charles University

214 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/VisiBroker 5.1 Dependency Of Delete On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 214 Copyright 2003 Distributed Systems Research Group, Charles University

215 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/VisiBroker 5.1 Evaluation The results indicate a significant increase in the create and delete times for a large number of servants. The memory usage observed during the test is roughly 2400 bytes per servant instance on the server and roughly 2200 bytes per proxy instance on the client. Confidential Page 215 Copyright 2003 Distributed Systems Research Group, Charles University

216 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Summary Dependency Of Create On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 216 Copyright 2003 Distributed Systems Research Group, Charles University

217 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Dependency Of Create On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to create a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to create the servant. Confidential Page 217 Copyright 2003 Distributed Systems Research Group, Charles University

218 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Confidential Page 218 Copyright 2003 Distributed Systems Research Group, Charles University

219 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Dependency Of Delete On Number Of Servants (1 Thread) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 219 Copyright 2003 Distributed Systems Research Group, Charles University

220 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Confidential Page 220 Copyright 2003 Distributed Systems Research Group, Charles University

221 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Dependency Of Delete On Number Of Servants (1 Thread, Zoom) The graph depicts the dependency of the time it takes to delete a servant on the number of active servants hosted by the server and the number of active proxies hosted by the client. On the X axis is the number of servants and proxies, on the Y axis is the time it took to delete the servant. Confidential Page 221 Copyright 2003 Distributed Systems Research Group, Charles University

222 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Confidential Page 222 Copyright 2003 Distributed Systems Research Group, Charles University

223 CORBA Comparison Project, Windows Visual C++ Platform Lifecycle Of Servant Instances/Summary Evaluation The results rate Orbix as the fastest broker in the scope measured by the suite for both creation and deletion of objects, TAO occupies the second and VisiBroker the third place. Orbix exhibits the best shape of dependency on the number of servants, TAO occupies the second and VisiBroker the third place. Orbix exhibits the smallest memory usage, TAO occupies the second and VisiBroker the third place. Confidential Page 223 Copyright 2003 Distributed Systems Research Group, Charles University