Re: Network Transparency

[Alexander Malmberg]

Michael Adams wrote:
> 
> This it dynamiclly loads is very good news.  I wasn't
> thinking of loading the backend over the network.
> Here is what I was thinking.  Normally you have an app
> that makes calls to a back.  One would write a new
> back that would be loaded with the app on machine A.
> This back would forward all calls made to it over the
> network to machine B.  Machine B is running an app
> that is a network front and that receives these calls
> and passes them to whatever back is installed on
> Machine B.
> 
> Here is the non-network typical case:
> 
> App --> back-art
>
> Using X11 as the transport (which you mentioned) we
> have this:
> 
> App --> back-x11 ==Over Network==> X Server

Most backends consist of two parts, "graphics" and "server", so you
actually have:

App --> back-art/x11 == X connection, possibly network ==> X server

> But here is what I'm thinking about:
> 
> App --> back-net ==Over Network==>
> front-net-app (need better name) --> back-art
> 
> The back-net/front-net-app pair acts as a tunnel to
> allow an app on machine A to use the back on machine
> B.  Also you aren't required to use X11 at all (though
> you could if you wanted to).
> 
> Is this possible?  Is there already a project doing
> this?

Yes, this is possible, and yes, the rds stuff I've been experimenting
with is essentially this.

(Although I've only worked on the local case, so it was:

App --> back-art/rds == DO connection ==> "display server"

with back-art rendering to shared memory and the "display server" just
displaying it; I haven't done any testing with doing the rendering on
the other end of the connection, so I don't know how it would compare
wrt performance when running locally; I'd expect it to be slower, but
there are many factors. Anyway, having the possibility of doing the
rendering in the "display server" is required in cases where you can't
use shared memory, eg. when connecting over a network, but I worked on
the local shared memory case first since it was easier :).)

[snip]
> Also,
> since GNUStep is more high level in the calls it makes
> (i.e. draw button instead of draw poly), I imagine
> streaming them over the network would be greatly more
> efficient (bandwidth wise) than X11.

This isn't true currently. -gui draws things by making lots of DPS calls
for rectangles and lines to the backend. It _could_ be made more
high-level by using DPS more heavily, ie. by defining ps functions in
the server and sending a single function call instead of sending lots of
small primitives. This would require lots of support in -gui.

(I don't know how much the bandwidth overhead of DO is, so all this may
be applicable only if rendering traffic is encoded directly.)

> If there is not already a project that is implementing
> this kind of net-back, I'm very sorely tempted to do
> it myself.  "It shouldn't be too hard."  (He he,
> famous last words.)  I probably don't have enough
> time, but ... arrg ... must resist ... coding urge.
> Like I said, I'm sorely tempted.

Help with any part of this would be appreciated. :) I haven't gotten
started on implementing anything "properly" yet, but I could collect
what I have so far and send to you if you're interested.

- Alexander Malmberg