[Opensim-dev] "Friendly teleports" between the standalone sims

[Tleiades]

> partially agreed :) the question is how much would we want to optimize and
> when. From my studies the calls to the backend services are only happening
> during the region changes - from my SL experience this is a tiny fraction 
> of
> the time spent. As such - isn't it a premature optimization in this case ?
Maybe a little guilty of premature optimization, but some of the flexibility 
in the engine isn't well thought out, and will lead to pretty bad user 
experiences, and all the indirections makes the code difficult to undestand.

>
> I would see the backend services model (backend services not as "UGA 
> infra"
> but as a specific class which is mostly responsible for the inter-region
> movement) as possibly being three layers:

I like the idea 3 layer idea :-)

>
> layer 1: "my" instance. Handles all the interregion stuff for this running
> instance of the sim. (since we can have multiple regions)
> layer 2: "this administrative domain". This is either a no-op in the case 
> of
> a standalone mode (since this administrative domain == this instance), or
> OGS in the case of grid services.
> layer 3: "interdomain". This handles either inter-sim or inter-grid or
> inter-sim-grid operations.
Agreed, local comms isn't the place to add inter-grid comms.

> Again - I have a feeling we are doing the premature optimization here. :)
> The reason I thought that the interdomain teleport is an important thing, 
> is
> that

Inter-grid teleport is important, I agree, but should we make it a priority 
right now?

>> Does the JIT really care if you are loading code on runtime?  Any
>> reference to performance information there would be appreciated.
Actually it does, the way the MS JIT compiler works, it will do a compile on 
the assemblies being loaded, so if two assemblies reference each other, and 
are loaded at the same time, the JIT compiler will optimize across the two 
assemblies. If the two assemblies are loaded independently, meaning assembly 
A is loaded and executed, and then assembly B is loaded. then the JIT 
compiler will not optimize across the assembly boundaries. A good way to 
test this is to observer how the JIT compiler will optimize away property 
get/set when two assemblies are loaded separately.

> depending on whether the above hierarchy is interesting or not, there 
> could
> be differing approaches. Maybe I misunderstood something (after all, I do
> remember myself being a strong advocate for doing everything via the
> loopback networking *only* in grid mode in the first place :) - but maybe
> the discussion again goes into the direction of question of UGA - while I
> was talking about the very specific component, responsible for 
> inter-region
> movement of agents.
My suggestion for using the IPC .net remoting protocol, was in order to 
reduce the code layers, this isn't only about performance (premature 
optimization) but also about code complexity and maintenance. Loading the 
4-5-6 different server modules into 4-5-6 appdomains when running a 
stand-alone grid, removes the worry about maintaining a local layer, meaning 
that we can focus on grid mode, and possibly inter grid. Effectively 
reducing into two layers, grid and inter-grid, since grid and stand-alone 
executes the same code, but uses different communications protocol. There is 
some similarity between remoting IPC and using the localhost address for 
communications, although I am of the impression that IPC does not touch the 
network stack.

/tleiades