Re: An idea: Apache Object Adaptor

[Michael Poole <poole troilus org>]

You're overlooking a few very important problems in the approach of
running CORBA over HTTP, and your analysis shows many signs of sloppy
buzzword-inspired thinking about scalability.

First, you ignore the overhead of going through HTTP rather than a
more CORBA-oriented protocol (like IIOP).  On the client, it's not
that hard and it doesn't matter that much, but on the server, having
Apache dispatch the requests properly makes for a big CPU cycle hit,
and for real scalability you don't want to over-burden the server.

Second, you don't really define scalability well.  I assume you mean
scalability to handle a reasonable number of potentially interacting
requests from many different clients (rather than scalability to
handle many linear requests from one client quickly).

Why does the definition of scalability matter?  Because the truly hard
part of scaling a server to many clients (and you can ask Oracle and
Microsoft and IBM's SQL server teams about this) isn't so much in
talking to all the clients -- how you do that efficiently is mostly a
function of the OS and its primitives for that.  The truly hard part
of scaling a server is making it concurrent, so that you can have
several requests being processed at the same time.  For this, no
performance-killing hack to add software layers will help; the server
must be written so that it does intellilgent locking.  And for this,
CGI scripts are very bad; there are no widely portable IPC locking
mechanisms available besides the problematic sysv ones, and those are
generally not very fast.

(Depending on the operations, having a single-threaded server might
give more throughput or even lower latency than a badly done
multi-threaded server, because the multi-threaded server tends to get
in its own way.)

Third, keeping state when the server runs as a CGI script costs much
more than just session-tracking.  If your server isn't long-lived, you
have to read data every time the server starts, and write the data back
before it stops.

So what does trying to run CORBA over HTTP win you?

* Buzzword compliance (hey, maybe this makes you happy)

* HTTP processing overhead (particularly on the server, where the cost
  matters the most)

* Concurrency headaches (worse than they need to be)

* Longer state recovery and recording times

-- Michael