Slashdot Mirror
Modelling P2P Networks
Nathan Kennedy writes: "Mihajlo A. Jovanovic did his Master's project at the University of Cincinnati on modelling P2P networks with Gnutella as a case study. You view his project along with source code, stunningly pretty pictures, an applet and a paper on scalability."
Some lawyer is looking at this page and trying to figure out what part of the DMCA has been violated and who they should call to ask for a job taking Mihajlo to court for them.
) Human Kind Vs Human Creation
) It'd be interesting to see how many humans would survive to serve us.
This doesn't look any more interesting just because it's Gnutella.
The pictures are cool but wouldn't one of the Fasttrack based P2P networks be a better example? I've got nothing against Gnutella but Morpheus and co seem to have scaled better. Is it because Gnutella is easier to test, its protocol more open, etc? Can anyone enlighten me as to why Gnutella would be better? Not trying to be a troll, just curious.
Looking at the charts it's really hard to get an accurate sense of gnutella's performance and scalability. Do the length of the lines correspond to the ping time, or physical location? What's the purpose of the circular chart? It would really be beneficial to include captions on each graph, to make it easier to understand. It would be nice to see a chart that relates the bandwidth, latency, number of connections, actual transfer rate, and ave connections all in a 3D visualization (not 3d bar chart). He could make a panorama of it. It might look like total garbage, or an organic structure.
Right, FTP is client - server, Telnet is client - server, instant messaging is client - server, ICQ is client - server, MSN Messenger is client - server. About the only one he got right out of his list of examples in NetMeeting.
Now his paper doesn't mention these examples so why include them in the introduction page.
The paper is well written and from a first skimming seems accurate and interesting - but that first paragraph on the introduction does nothing to enhance the paper.
Matt Thompson - Actuality - Insert product here.
What is important : These networks are highly clustered, and as such the current Gnutella algorithms don't take advantage of that and do a lot of duplicate work, leading to an in-efficient use of bandwith and problems in scaling.
This conclusion is rather interesting for someone who is into distributed processing (although I'm not sure how "d'uh!" obvious it is to most) but even more interesting is that its all based upon empirical evidence (of course using a mathematical basis).
So don't just look at the pretty pictures!
In the future, I would want to not be isolated from my friends in the Space Station.
One problem with LimeWire's initial implementation is that ultrapeers didn't respond to "crawler pings" with "leaf pongs". (We've since changed that.) So as pretty as these pictures are, they're probably not accurate. I would love to see updated results that accounted for ultrapeers.
The Gnutella network is evolving rapidly, and it would be great if academic papers considered these changes. The Gnutella Developer Forum (GDF) is the primary location for protocol development.
Christopher Rohrs
Sr. Software Engineer
LimeWire
P2P's other fruits may include:
* Distributed storge like FreeNet
* Instant Messaging
* Anything else you can think of that may need to be decentralized.
The advantage of a P2P network is that no single entity controls it and everybody shares the costs.
"Communism is like having one [local] phone company " - Lenny Bruce
I'd say it's simply that P2P is where the same nodes are both client & server. This is the case with Gnutella, Morpheus etc, but is not the case (typically) with ICQ, Messenger, et al. FTP and Telnet are interesting, as it's perfectly possible for the same machine to run both telnet and telnetd, but I would still argue that's the exception rather than the rule. The protocol was designed with a simple concept of server and client.
As for DNS, from my hazy understanding (please correct me if I'm wrong) the client makes a request to one server, which redirects it if required to a different server. So the client lookup part of the protocol is certainly client server. The other parts (syncing changes etc) is outside of my realm of knowledge, but that could be considered p2p I guess.
I certainly agree that p2p is nothing new, just a new phenomenon in terms of popularity.
---- Den ene knappen er powerknapp, den andre er Bender voice knapp "Bite My Shiny Metal Ass"
But, you may argue, DNS and UUCP aren't truly P2P, because they themselves are servers. Is that the only thing which differentiates the new wave of P2P apps? The fact that they are monolithic? What if you split a Gnutella client into two parts -- a "server" which does the communication with other Gnutella nodes, and a "client" which is the GUI front-end? In that case, you'd have a system which was pretty much exactly analogous to UUCP and DNS. Especially if you could run the Gnutella client on a different machine from the Gnutella server.
There's not a lot of difference - to my mind it's to do with usage & populations. In the case of DNS, the servers are peers of each other, but there is a secondary population of "pure" clients, i.e. desktop machines which never act as servers. From their point of view, DNS is purely client server. With Gnutella however, as it stands, every client is also a server - there's only one (hetrogeneous) population. If you split the binaries as you suggest, you would create the potential for people to run either only the server or only the client, and thus, parts of the network would become client server.
What does this mean? Really that there is very little technical difference (if any) - it's more that the "p2p" apps encourage/mandate that all users are equal (i.e. peers), pure clients or servers do not exist. Maybe we could think of it as a grey scale, with pure p2p at one end and pure client server at the other. Most protocols are somewhere along the line, very few are at either end!
---- Den ene knappen er powerknapp, den andre er Bender voice knapp "Bite My Shiny Metal Ass"
The real thing going on here I think is that these new Gnutella, Freenet are all self-discovering networks. DNS requires you to build a tree of servers that all know about each other, you can't just start a dns server without telling a root server about yourself (this has to be done by hand). Unlike other other protocols, gnutella and kin keep track of all the servers that are running.
I guess the real problem with all these servers is that they are trying to do the impossiable, that is they want to search the entire internet