While, I'm not sure how future-generation scalable decentralized networks file will be organized, I'm sure it won't be around ultrapeers. Here's why:
Say you have 100 nodes that are sharing files, and you wish the search the file libraries of theses nodes. The most obvious solution, and the one used by the original (0.4) GnutellaNet, is to send a query to every node. Now, if the query traffic of the network is 20KB/s, then every node must be able to support this level of traffic.
An improvement on this scheme is to use ultrapeers. One node out of the hundred is selected, all the other nodes report the contents of their libraries to it, and only that node is queried. This is somewhat of an improvement as it means that 99 out of the 100 nodes need support only a very small level of traffic. However, one node is still left needing to support the full 20KB/s of query traffic.
Consider an alternate solution: instead of every node reporting its library to a single other node, have every node report its library to every other node. With this configuration, only one of any of the nodes need be sent each query. If the queries are evenly divided between the nodes, then each node need only handle .2KB/s of traffic.
It seems to me that the alternate solution is the better one. It still isn't perfect however: at some point the overhead involved in reporting the library contents to every other node will outweight the reductions in query traffic.
The problem with scalability in all current decentralized file-sharing networks is that adding nodes hurts the network. Using superpeers doesn't eliminate this problem, either; it simply causes a linear reduction in the apparent network size. In order to be scalable, adding nodes must not harm a network. Moreover, there's no reason to think a solution to this problem isn't possible. Each new node on a network contributes to the network's aggregate capacity. Why shouldn't this strengthen the network, rather than harm it?
|