[p2p-hackers] Models for distributed systems

[tstrufe]

Thanks for the hints!

|>Correct me if I'm wrong, but I think the main
|>difference is that, in c/s, any given node is either
|>client or server, but in p2p a node can be both client
|>and server at the same time...
Well, if you consider the dynamic client/server model (client server
with delegation) you get the same behaviour. Servers delegate subtasks
to other servers, and hence become clients for a certain amount of time,
in many c/s-systems.
I suppose the difference is, that in P2P every node can be the
originating source of a request, while in dynamic c/s the source is
always a /client/.


| But Thorsten asked more specific differences, and imho,
| routing is one specific feature of P2P (file-sharing -- Gnutella/Kazza,
| DHT, ad-hoc wireless network, etc.).
I thought about this fact as well, but if that is the defining
characteristic of P2P we had to call any routing system P2P, hadn't we?
The problems solved in the system domain seem to be the same then.

I've got as far as defining P2P as a system architecture (here comes the
first question: does anybody know a good and formal definition of system
architectures?).
The system architecture can be best described with three different models.
~ * In the role model (formal definitions?): P2P knows of only one role,
the servent. Every servent performs, or at least is able to perform the
same tasks (symmetric roles), which usually consist of searching its
local or locally registered ressources, forwarding search requests and
serving an offered ressource.
* In the interaction model (formal definitions?): Similar to the
client/server model interaction in P2P architectures is done
asynchronous via request-response message pairs. Any node can be the
originating source for a request.
* In the organisational model (fd?): No context knowledge other than a
bootstrapping point to one occurence of a specific P2P system is needed
to take part in it. There is no central naming system (anyway, it is
possible to introduce an distributedly implemented algorithmic naming
system as is done with Hashvalues in DHT-Systems). 'Pure' P2P systems
are not structured at all (anyway, it again is possible to introduce a
distributedly implemented structure as the supernodes in gnutella v0.6).

Following this definition, a better word for P2P would probably be
decentral distributed systems or collaborative systems (if this term
wasn't already occupied by the cscw-world).

I'm perfectly aware of the fact that this definition does not cover
***@home, napster and a fair share of other (file-sharing) systems, but
it's still the best definition that I can come up with at the moment.
And I would be highly interested in other views! :-)

Thanks for comments in advance!

thorsten

[Crosbie Fitch]

Post by tstrufe
Thanks for the hints!

I'm perfectly aware of the fact that this definition does not cover

Post by tstrufe
it's still the best definition that I can come up with at the moment.
And I would be highly interested in other views! :-)

Maybe a key difference is that a p2p system is self-organising, i.e. no
specific role is given to any specific computer.

Fundamentally, there is a movement away from inflexibility in terms of
system architecture towards flexibility, whether one, two, or a million
computers are involved. With this flexibilty comes potential for greater
efficiency, i.e. load balancing (storage/bandwidth/cpu), bottleneck
elimination (scalability, fault tolerance), transparency (less need to
identify resources by name or location), etc.

A client/server setup is in some ways a p2p system where a human has
determined the optimum configuration, e.g. this computer (server) is
massive/stable/secure and thus is best suited to assume 99% of the workload
and roles, whereas these computers (clients) are small/unstable/insecure and
thus are best suited to assume 1% of the workload.

So, I think we're really looking at a spectrum of system architectures where
at one end roles, responsibilities, etc. are completely manually and
statically defined, whereas at the other end they're fully automatic and
dynamically defined.

To some extent the Web is a p2p (distributed) system, it's just that a large
aspect of each computer's configuration/relationships are determined
manually (content, Apache, etc.) although another aspect is determined
automatically (BIND, NNTP, SMTP, etc.).

I'm not sure that a boundary (or boundaries) exist on this spectrum. Perhaps
one can say that there are aspects possessed by some architectures, e.g.
single/identical servent software package.

Even at the far end of the spectrum, it does not matter what behaviour the
system exhibits or organisation that it adopts (even if indistinguishable
from a client/server setup), as long as it is self-organised by its
constituents and continuously able to adapt to change without requiring
human assistance.

[tstrufe]

Crosbie,

Post by Crosbie Fitch
Maybe a key difference is that a p2p system is self-organising, i.e. no
specific role is given to any specific computer.

That's what I meant by writing that any structure or naming can only be
done algorithmic on every node. If you look at gnutella 0.4 there is no
organisation at all... ;-)

Post by Crosbie Fitch
Fundamentally, there is a movement away from inflexibility in terms of
system architecture

I understand this statement and I wouldn't want to introduce new bonds
to any static architecture, but the wish to formally describe such a
systems leads to the need for some static points, that you can pin P2P to...

Post by Crosbie Fitch
A client/server setup is in some ways a p2p system where a human has
determined the optimum configuration, e.g. this computer (server) is

Decentral organization in a distributed algorithmic way vs.
context-knowledge, yep.
One could say that P2P is a very specific occurence of C/S (dynamic, no
naming system, no predefined structure) as well...

Post by Crosbie Fitch
So, I think we're really looking at a spectrum of system architectures where
at one end roles, responsibilities, etc. are completely manually and
statically defined, whereas at the other end they're fully automatic and
dynamically defined.

Agreed, as seen above :-)

Post by Crosbie Fitch
To some extent the Web is a p2p (distributed) system, it's just that a large
aspect of each computer's configuration/relationships are determined
manually (content, Apache, etc.) although another aspect is determined
automatically (BIND, NNTP, SMTP, etc.).

Well I would disagree here, as 'the web' is not one system but a
collection of many. And almost each subsystem is C/S pretty straight
forward.

Post by Crosbie Fitch
I'm not sure that a boundary (or boundaries) exist on this spectrum. Perhaps
one can say that there are aspects possessed by some architectures, e.g.
single/identical servent software package.

See "Role Model" -> symmetric roles...

Post by Crosbie Fitch
Even at the far end of the spectrum, it does not matter what behaviour the
system exhibits or organisation that it adopts (even if indistinguishable
from a client/server setup), as long as it is self-organised by its
constituents and continuously able to adapt to change without requiring
human assistance.

OK, so we'd agree, that no context knowledge is needed (other than the
bootstrapping-point) and any structure whatsoever has to be achieved
through distributed algorithms.

Thanks for the insights! :-)

I'm still after good definitions for the formal models, though, and I'd
be glad for more comments...

thorsten