[coyotos-dev] Hi + some stuff I found researching

[Jonathan S. Shapiro]

On Wed, 2006-07-12 at 17:48 -0400, Haplo wrote:
> 2:It's explicitly stated that your initial target application will be  
> mission critical applications. Now, to say that people developing  
> drivers for such applications will very carefully design and test  
> them would be accurate. To say that they would be entirely error free  
> is optimistic. Optimism isn't really appreciated when people's lives  
> or millions of dollars might be at stake, and in this case the  
> healing layer provides a level of protection against a worst-case  
> scenario. I'm pretty sure that's something which CAN be appreciated  
> by that particular audience.

Haplo:

There is a place in the world for a restart mechanism. I'm not arguing
that. What I'm saying is that the initial applications for Coyotos are
applications where, if we need to invoke the restart layer, it's already
too late.

> about A:
> That would depend on the implementation, but the various nuances of  
> that are beyond the current scope. We can discuss that when you come  
> to it.

Regrettably, it does *not* depend on the implementation. A channel is a
channel. You can only argue how big. Yes, the implementation has a lot
to do with how big the channel is.

> about B:
> Well, that wasn't exactly a very resolute response. The big question  
> is, how would it fly on x86 and popular RISC architectures? On one  
> hand, it could be a big win for IPC performance, but only if there's  
> a wide enough scope of "yes".
> 
> As for them being disk structures, I'm quite aware of that. The  
> question is how often would they be on disk and how often in resident  
> memory? If they're typically only on disk for persistence, then the  
> question becomes the serialization cost.

Definitely no value in IPC, and definitely no value in capability pages
because you *can't* serialize the pointers in the way you are thinking,
the data structures are shared in ways that you aren't taking into
account, and traversing the address tree is much much faster than the
design that you are sketching in any case (because of caching). In my
experience, no value for the whole technique on RISC processors, but I
certainly haven't made an exhaustive study.

This is one of those cases where yes, it's a clever space of techniques,
but I'm only going to consider these techniques on a case by case basis
where a specific argument is made about a specific problem. In general,
these techniques are machine dependent and difficult to maintain -- both
issues that argue strongly *against* them unless the performance need is
profoundly overwhelming.

In Coyotos, that need doesn't seem to exist at the moment, but who knows
what the future may bring.

Performance isn't the primary goal for Coyotos. Robustness is.

Litmus test question: if you implemented an algorithm like this, how
soon would you run it on your (personal) defibrilator?


shap