[ILUG] D11, basically implement X11 server like an os kernel ?

[Caolan McNamara]

Now i know most of you read slashdot, and so on, but still a very
very interesting nugget of information about how to speed up X11
a lot can be found at.

http://reality.sgi.com/opengl/d11/d11.html

The gist appears to be that this D11 would be the exact same as X11
for networked apps, but in the case where the app is running on the 
same machine as the Xserver itself then some trickery comes to play.

Traditionally whats going on when you are an X app and talking to the 
Xserver is that your request is turned into a sequence of message bytes,
which are sent of through a transport mechanism (tcp/ip for the networked
case, and a domain socket (i think), for the local case). The point being
that the Xserver then receives the message sequence and decodes it and runs
the appropiate function, got me ?, This is alright for things like
XMoveWindow and so on, but of course doing something like an XGetImage requires
that the data gets turned into a byte stream (can't pass a pointer to
the area to be copied over the network now can you eh!), and so on. (though I
might be wrong in my choice of example, a lot of stuff is done by X to try and
keep the data on *one* side of the X connection, usually the server). But still
this whole serialization of the requests and the unpacking afterwards is a slow
process is a bottleneck.

This D11 approach looks simple enough (famous last words). For the networked 
case you continue as always X, when you get down to it, is incredibly efficient
as a networked graphical system, just slightly inappropiate for a local 
graphical system. For the local system, rather than serialize the requests, the 
D11 library (probably at start up one would imagine) instead makes the decision 
to call the appropate Xserver functions directly from process space. So you 
imagine and implement your XServer (DServer ?) as a oslike kernel, with a list
of functions that can be called directly from process space. The idea seems
massively simple in concept.

You avoid packing and unpacking the protocol stream.
You don't have *any* transport mechanism to be pushed over, just a function call
You can do some interesting things with Pixmaps where you keep them in the 
client rather than the Xserver, which can be a big plus as well.

I wonder what the practicalities of implementing it would look like. But i 
really reccomend you take a look at the sgi paper, and have a good think about
it. Would be a very worthy project to have a stab at implementing/investigating
it i reckon. The biggest benefit is better speed through implementation, rather
that any new standard being required, D11 programs run on X11 servers, and X11
run on D11. If this was ever to pan out, you could replace the linux X11 
libraries and Servers with D11, and still be able to talk to the rest of the 
world without any issues.

Hmmm, i suppose what you could do to start off is just look into the 
practicalities of modifying the XFree Xserver to make it possible. Any ides ?

C.

Real Life: Caolan McNamara           *  Doing: MSc in HCI
Work: Caolan.McNamara at ul.ie          *  Phone: +353-86-8790257
URL: http://www.csn.ul.ie/~caolan    *  Sig: an oblique strategy
Don't be frightened of cliches