Friend-to-Friend (F2F) Computing
The Spontaneous Desktop Grid
Friend to Friend (F2F)-Computing is a new paradigm for ubiquitous and distributed computing, merging ideas from peer-to-peer, Cloud Computing, and social networks. F2F Computing is offering a middleware on top of the multi-protocol instant messengers. On top of this middleware you can write simple distributed applications and services.
For issue-tracking, see: http://code.google.com/p/spontaneous-desktop-grid/issues/list
- F2F LLVM Computing Engine (0) - Friday, April 1, 2011 22:21 EET - artjom85LLVM Computing Engine has been recently updated to support LLVM versions 2.7 and 2.8. The Low Level Virtual Machine compiler infrastructure is used to run the High Performance Computing C/C++ code remotely and platform-independent.
- F2F Development Page (0) - Friday, April 1, 2011 22:18 EET - artjom85Updated F2F Development page, added module descriptions, the list of development requirements, also provided short repository description including current tags and branches.
- F2F Security (0) - Wednesday, March 23, 2011 17:10 EET - artjom85Security is the most vulnerable part of any P2P system. In F2F we are bootstrapping P2P TCP communication using existing IM protocols (which are secure and authenticated by default). However the flexible communication layer of the F2F Computing allows to operate in TCP only (after successful bootstrap routine). In other words once the peer joined ...
- F2F Java Console Front-End (0) - Wednesday, March 23, 2011 17:10 EET - artjom85Java is a popular mainstream language its support is essential to increase the F2F Developers Community. In the beginning of this year we implemented JNI support in F2F Core, now the pure Java development (without even thinking of F2F C-nature) is possible. Currently we are working on stabilizing the first Java based F2F console Front-End ...
- F2F IPv6 Proxy (2) - Wednesday, March 23, 2011 17:09 EET - artjom85The IPv4 is officially exhausted, and there are number of services in the Web already which are IPv6 only (exmple: ipv6.google.com). However the major ISP are still using IPv4 preventing direct routing to IPv6 sites. Currently the issue is solved by tunneling the IPv6 routes through IPv4 networks. However the setup is not intuitive enough ...
- 08.03.2011: ulno.net migrated to wordpress, f22f available as git-repository here.
- 21.01.2010: The pidgin plugin is running, the build scripts are about ready to be released. We started to work on a port of F2F Computing to Android. The core already translates.
- 24.10.2009: Talking about F2F Computing a lot here on the mentor’s summit, it think I should write a small note. We are still shifting to the new C and LLVM based version of F2F. Still there is no real new version, the pidgin plugin will come soon – if you are interested in getting a peek, please contact us in person.
- 28.11.2008: For the eager ones between you and for my students, here is the source release of the next f2f version. Just unpack, go to F2FCore/src, and run python build.py release to compile your own release (you need python, a c compiler, swig, and scons, compare the development page). This version is now also fixed for 64 Bit systems (02.12.2008) and supports the creation of ringtopologies (04.12.2008).
- 11.11.2008: New development documentation available: Getting started with the F2F Computing development, added the F2F logo on the logos page (you can also click on the logo).
- 09.11.2008: F2F Computing currently undergoes a serious rewriting process. The core is rewritten in C and the architecture enables now different language backends and plugins for different instant messengers. Furthermore, we have now an F2F headless client, which you can even submit to real grids (tested on nordugrid/Arc and balticgrid). F2F Computing will also be available on mobile clients. take a look at our F2F goes Mobile project.
- 27.08.2008: Releasing officially our 0.0.2 release – bugfixes
- 05.06.2008: Releasing officially our 0.0.1 release – go, get it while it’s hot!
- F2F Computing goes Mobile
- F2F Pidgin Plugin
- A Low Level Virtual Machine Backend for F2F Computing
- F2F Computing – interactive: interactive applications for F2F Computing
- Getting started with the F2F Computing development
If you are brave, you can also directly try one of our releases. Just unpack it and start either the sh or the batch file. You find examples in the examples-folder.
- 0.0.3 (04.12.2008): source release, this is already the gui less new f2f version, a gui will follow soon
- 0.0.2 (27.08.2008): This version should work. f2f-0.0.2.zip
- pre0.0.1 (20.06.2007) artjom provides here a little older version without the issues of 0.0.1. I t however lacks the topology support. f2f-pre0.0.1.zip
- 0.0.1 (05.06.2007) f2f-0.0.1.zip: includes MPI, basic UDP-NAT-traversal, and the data-gatherer for the topology visualizer. This is the reference work for the thesis of Andres Luuk, Keio Kraaner, Artjom Lind, Raido Türk, and Indrek Priks. Sorry, we discovered some major bugs in this version.
Versions of the visualizer, you find here:
If you want to try out the blender example in there, you will also need blender preinstalled on all client computers. The Blender executable has to be in the PATH.
However, if you seriously want to use f2f, you will need at least the F2F development module to create your own F2F applications.
The F2F v2.0 documentation is a little obsolete now, as we are rewriting F2F Computing. Have a look at “Get started with the F2F Computing development“.
- Fall 2007: Lab-Course: Spontaneous Desktop GRID: Friend to Friend (F2F)-Computing
- Spring 2007: Lab-Course: P2P Grid Software Project/ Friend to Friend (F2F)-Computing
A small introduction
Current trends in scientific computing/computational science show the increase of the needs for more computational power. Some examples are large-scale simulations in environmental and engineering science, pharmacy, and chemistry. At the same time, computer architectures move more and more towards distributed and multi-core processor architectures. Therefore, parallel and distributed computing becomes more important. One way to facilitate increased computational power is super or cluster computing.
At the same time, Grid computing is becoming more important as it networks single computers, servers, supercomputers, clusters and special devices into a global resource. Grid computing tries to network different computing centers, companies, and universities and make the networked resources available to research groups and companies. Various frameworks exist to support GRID Computing, like the Globus Toolkit, UNICORE, or the Condor Project. The programming model for grid computing is still on the level of batch processing of embarrassingly parallel algorithms (processors do not communicate with each other). Communication crossing the individual grid-node borders is extremely complex.
Nowadays, grids are very heavyweight and complex, especially submitting small jobs is in no relation to the administrative support needed to run the grid infrastructure. The initial metaphor for the computational grid being as easy as a power grid is still unfulfilled (Compare NewWindow(“http://mig-1.imada.sdu.dk/MiG/Mig/published_papers/The_Grid_Taken_Literally.pdf”,”B. Vinter et. al.: The Grid Taken Literally”)). The resources in Grids are centrally managed by IT professionals. Hence, they create a considerable amount of work to administer and maintain.
A step to making networked computing power more accessible to the public is Public-Resource Computing as proposed in the BOINC approach. It enables the Desktop GRID, actually networking home-PCs to a GRID. Famous examples, using this, are SETI@home and Einstein@home. This approach is still targeted at small research groups trying to solve problems which take an enormous computational effort in terms of computational time, usually needing years to compute.
As computational demands for applications and simulations continuously grow, making more computational resources publicly and easily available, it is very interesting for small research groups, individual researchers, or small companies.
To facilitate a public usage of Grids even more, we extend Grid computing with techniques from peer-to-peer computing combined with instant messaging. Instant messaging is used by the vast majority of computer users. We assume, that using instant messaging techniques for the administrative part of setting up the Grid will open Grid capabilities to the public and enable thereby a personal Desktop Grid. It provides a new approach for authentication and authorization.
As skype made voice-over-ip usable by everyone and encouraged by the popularity of the SETI@home project, we think that the simplicity of forming social networks with mutual trust in current instant messaging systems will overcome the administrative problems persisting in nowadays Grid middleware.
Hence, single researchers, very small research groups, and small companies will be able to combine their computational power with their friends or colleagues and be able to solve their computational intense problems much faster than today. The ease in administration and scalability already observed in Public-resource computing due to its Peer-to-peer manner will also apply to our Spontaneous Desktop Grids as these are also formed in a peer-to-peer manner.
Analogue to peer-to-peer the here applied paradigm is called friend-to-friend computing (F2F computing) as a contraction of Grid, peer-to-peer, and friends relating to the spontaneously formed social networks.
The research is driven by implementing and evaluating the following three scenarios. Their underlying ideas is to support scientists or students in small projects.
1. Simulation Boost
- A chemistry (further planned scenarios apply to fields of mathematics, bio-informatics, physics, or biology) student needs to run a simulation – here of a reaction. The student has to do this multiple times with different input parameters. To accelerate getting the results the student asks colleagues and friends to share their computational power. (Applying a decomposition tool for solving partial differential equations like DOUG could also be a usecase here.)
2. Dynamic Rendering Grid
- Some arts students or a small movie studio want to render a part of an animation movie (compare for example Elephant’s dream). To speed up this process they create in their instant messenger a chat group and start the dynamic GRID to carry out the distributed rendering task.
3. Language Analysis
- For OCR, automatic analysis of texts, speech recognition, and automatic translation huge trees and databases on language files have to be computed. To create these data files some weights have to be adjusted and the files have to be re-created, resulting in a very time consuming process. This could also sped up with spontaneous GRIDs established in a F2F manner.
F2F computing will enable small research groups, research individuals, and small to medium sized software companies to solve computational intensive tasks with their own means. It will probably have an impact on scalability of current Grid projects and will yield results for simplified Grid application development.