The PEPITO project is investigating the foundations of scalable distributed computing in general and peer-to-peer (P2P) computing in particular. The project is starting its second year. The initial proposal implicitly presents a sketch of a generic P2P framework, in the way that workpackages and tasks are organized. After one year, we have designed a generic P2P infrastructure, and we have made progress in implementing it. As we see it, the P2P infrastructure has a layered structure with three levels. The basic guiding design principle in each layer is one of cooperation: all nodes (machines/processes) are orchestrated to help each other achieve the common goals of scalability, reliability, dynamic connectivity, and self-management.
The first layer consists of autonomic topology maintenance. The network is a self-healing graph of nodes with the ability to route messages, to join (add new nodes at any time), to leave (either explicitly or implicitly due to failures), and to merge (large numbers of nodes leaving or joining simultaneously). The network provides guaranteed bounds on the number of messages and network hops needed for these operations. Current work on the architecture is described in paper 4 of deliverable D2.7 of WP 2 (distributed algorithms and services) on DKS(N,k,f): A family of low-communication, scalable and fault-tolerant infrastructures for P2P applications. We are implementing this infrastructure in WP 4 (distribution subsystem).
The second layer consists of basic P2P services implemented by distributed algorithms. A first service consists of scalable broadcast and multicast, as shown in deliverable D2.7 of WP 2. The broadcast is described in paper 3: Efficient broadcast in structured P2P networks. The multicast is described in paper Probabilistic Multicast. An important part of this service is the management of group membership. A second important service is a reliable distributed dictionary that can map names to any values (including network references).
The third layer is a language-independent middleware layer that provides services for different programming systems to support distribution, mobility, and security according to the semantics provided by the respective programming language. Current work on this layer is described in deliverable D4.2 of WP 4. This layer is complemented by a programming language interface for each system in which it is used. Progress on integration of the middleware layer with the programming systems Mozart/Oz and Java/Scala is reported in WP 3 (programming languages). This integration provides a higher level of abstraction than the service layer, making it suitable for P2P application developers.
We are starting work on applications using the middleware layer. For example, we have started work on a P2P application for collaboration among children in schools in WP 5 (applications). We expect that these applications will clarify what the API of the middleware layer should be.
We have done foundational work on several levels. At the P2P-architecture level on anonymity and censorship resistance in D1.7 of WP 1 (formal models); in the messaging services of the distributed middleware on a precise semantics, including failure, for the UDP and TCP protocols, see D1.7 of WP1; at the distributed programming level on a calculus for mobility, see D3.3 of WP3; and the axiomatization of distributed transactions. There still remains work to be done on what is promised in the project as a P2P calculus.
During the first twelve months of PEPITO we organized two workshops. The project has a web page http://www.sics.se/pepito where activities are visible to the consortium and the outside world. The presentations given at the workshops are available on this web page. A number of papers were submitted to major conferences and some accepted (see below). Cooperation is developing as expected including cooperation with other projects for submitting FP6 proposals.