> >> Almost. I worked on a production CORBA system with applet client
> >> and custom server for intranets (1-5000 users, no
> tunneling or anything).
> >> We did a trial conversion to RMI & EJBs, and found the
> performance of RMI
> >> to be significantly better than CORBA, though that may be
> due to the fact
> >
> >As I understand, the idea of IIOP is to be Interoperable,
> not necessarily
> >efficient to serialize in Java. Apparently JRMP is quite a bit more
> >efficient/fast than IIOP, and some third-party RMI protocols
> (WebSphere's,
> >Orion's) are potentially even more efficient/fast.
Have you run any benchmarks to "prove" this!?! I'm writing a generic load
test suite with plugins for SOAP, CORBA, RMI, EJB, and local method
invocations.
Below you'll find fresh (5 minutes old) results comparing JavaIDL/IIOP
(probably a rather crappy ORB) and RMI/JRMP (from SUN). There might be
something suspicious with my code, but both the CORBA and the RMI plugin
gets called from the same plugin-manager class. I ran the test on WinNT 4 sp
5 using JDK1.3.
The methods that the plugins implement are list below:
public void basicTest(short s, double d, String str) throws Exception;
public void blobTest(Blob b) throws Exception;
public void fooTest() throws Exception;
public void byteArrayTest(byte[] data) throws Exception;
Blob is a "value object" with three members: short s, double d, String str.
Test results:
Format:
test name (method)
3 * "time (in msecs) to make 3000 calls"
Total time, i.e. time0 + time1 + time2
Avg time: i.e. TotalTime/3*3000
--- JavaIDL / IIOP ---
Number of iterations: 3000
Number of runs: 3
Roundtrip (foo) results:
1533 1452 1452
Foo total time: 4437 msecs
Foo avg time: 0.493 msecs
Value objects (blob) results:
1662 1583 1563
Blob total time : 4808 msecs
Blob avg time : 0.5342222 msecs
Simple types (basic) results:
2103 1582 1542
Basic total time: 5227 msecs
Basic avg time: 0.58077776 msecs
kbps (bytes) results:
1792 1662 1702
Bytes total time : 5156 msecs
Bytes avg time: 0.5728889
kbps: 1745.5392
--- RMI / JRMP? ---
(rmic -d .. generates JRMP stubs by default?)
Number of iterations: 3000
Number of runs: 3
Roundtrip (foo) results:
1021 1012 1031
Foo total time: 3064 msecs
Foo avg time: 0.34044445 msecs
Value objects (blob) results:
2744 2143 2143
Blob total time : 7030 msecs
Blob avg time : 0.78111106 msecs
Simple types (basic) results:
2384 1382 1252
Basic total time: 5018 msecs
Basic avg time: 0.55755556 msecs
kbps (bytes) results:
2233 2103 2023
Bytes total time : 6359 msecs
Bytes avg time: 0.70655555
kbps: 1415.3168
The test result seems to match Rickard's comments (see below). Wondering why
the time drops for each test run (i.e. time0 > time1 > time2) - it's the
HotSpot compiler in action ;-)
This test doesn't show you anything (as I haven't release it source code so
you can't really reproduce my "findings"). However I would appreciate if we
try to stick facts and not hearsay ;-)
IIOP is not necessarily an evil thing or even a slow thing, neither is JRMP.
I think that IIOP has some strength: it's proven that it works and that it's
scalable, it support service contexts (usefully for various things) and it
is actually rather efficient. However I'm not familiar with JRMP so I can't
really comment on that one:-)
My 2 cents ;-)
/Per
> Yeah. One of the most slow things in JRMP, or serialization
> in general, is
> the class descriptors. JRMP does it "the right way" with
> version id's and
> whatnot. It would be possible to make it simply send the name
> of the class
> instead (i.e. more like Externalizable works), but then all
> these nice "you
> have the wrong version" messages would go away, and instead
> we would get
> mysterious errors sometimes because there was a mismatch in classes.
>
> Overall JRMP is pretty ok, and when we get the asynch I/O
> stuff in JDK1.4,
> wow, that will be *seriously cool*...
>
> /Rickard
--
--------------------------------------------------------------
To subscribe: [EMAIL PROTECTED]
To unsubscribe: [EMAIL PROTECTED]
Problems?: [EMAIL PROTECTED]
