One of the reading club assignments was to read the paper about Google Pregel and Signal Collect, compare them and point out pros and cons of both approaches.

So after I read both papers as well as Claudios overview on Pregel clones and took some notes here are my thoughts but first a short summary of both papers.

Summary of Google Pregel

The methodology is heavily based on Bulk Sychronous Parallel Model (BSP) and also has some similarties to MapReduce (with just one superstep). The main idea is to spread the data over several machines and introduce some supersteps. For each superstep every vertex of the graph calculates a certain function that is given by the programmer.
This enables one to process large graphs which are distributed over several machines. The paper describes how to use Checkpoints to increase fault tolerance and also how to make good use of the Google File System in order to partition the graph data on the workers. The authors mention that smarter hashing functions could help to distribute the vertices not randomly but rather in a way they are connected on the graph which could potentially increase performance.
Overall the goal of Google Pregel seems to enable one to process large graph data and gain knowledge from it. The focus does not seem to increase the usage of the calculation power of the distributed system efficiently. In stead it rather seems to create a system that makes distribution of data – that will not fit into one machine – possible at a decent speed and without much effort for the programmer by introducing methods for increasing fault tolerance.

Summary of Signal Collect

Signal Collect as a system is pretty similar to Google Pregel. The main difference is that the authors introduce a threshold score which is used to decide weather a node should collect its signals or weather it should send signals. Using this score the processing of algorithms can be accelerated in a way that for every super step only signals and collects are performed if a certain threashhold is hit.
From here the authors say that one can get rid of the superstep model and make the entire calculation asynchronous. This is done by introducing randomization on the set of vertices on which signal and collect computations have to be computed (as long as the threasholdscores are overcome)
The entire system is implemented on a single machine but the vertices of the compute graph are processed by different workers (in this setting Threads). All Threads are able to share the main memory of the system which makes message passing of Signal and Collect computations unnecessary. The authors show how the increasing number of workers actually antiproportionally lower the runtime of the algorithm in the asynchronous setting. They also give evidence that different scheduling strategies seem to fit the needs for different graphs or algorithms.

Discussion of Pros and Cons

  • From the text above it seems very obvious that Signal Collect with its Asynchronous Programming model seems superior. But – in opposite to the authors – I have hidden to mention the drawbacks of one small but important detail. The fact that all the workers share a common knowledge which they can access due random access in main memory of the machine allows their model to be so fast while being asynchronous. It is not clear how to maintain this speed with a real distributed system. So in this way Signal Collect only give a proof of concept that an abstract programming model for graph processing exists and it enables fast distribution in theory.
  • Pregel actually is a real frame work that can really achieve distribution of large data to clusters of several thousand machines which for sure is a huge pro.
  • Signal Collect proposes to be more general than Pregel since Pregel can only respect one vertex type and edges are stored implicitly. Whereas Signal Collect is able to store RDF Graphs. I personally understand that Signal Collect can only send signals from one vertex to another if and edge exists and is also not able to add or remove edges or vertices. In this sense I still think that Pregel is the more general system. But I guess one can still argue on my point of view.
  • Pregel’s big drawbacks in my opinion are that the system is not optimized for speed. As already discussed in the last meeting of the reading club Map Reduce – with its one Superstep attitude – is able to start Backup tasks towards the end of the computation in order to fight stragglers. Pregel has to wait for those stragglers in every superstep in order to make synchronous Barriers possible.  
  • Another point that is unique with Pregel is the deep integration with Google File System (btw. I am almost through the google file system paper and even if you already know of the idea it is absolutely worthwhile reading it and understanding the arguments for the design decisions of the google file system). So far I am not sure weather this integration is a strong or a weak point. This is due to the fact that I can’t see all the implications. However it gives strenght to my argument that for a distributed system some things like network protocols and file systems should be considered since they seem to have a strong impact on the entire system. 
  • Both systems in my opinion fail to consider partitioning of the graph and a different network protocol as an important task. Especially for Pregel I do not understand this since it already has so much network traffic. Partitioning the graph might increase start up Traffic on the one hand but could increase overall traffic on the long term. 

Outlooks and personal thoughts:

I am considering to invite the authors of both papers to next weeks reading club. It would be even more interesting to discuss these and other questions directly with the guys who built that stuff. 

Also I like Schegi’s idea to see what happens if one actually runs several neo4j servers on different machines and just use a model similar to Signal Collect or Pregel to perform some computations. In this way a programming model could be given and research on the core distribution framework – relying on good technologies for the workers – could be done.

For the development of the first version of metalcon we used memcached. I read a lot that memcached scales perfectly horizontal over several machines. I wonder how an integration of memcached to Signal Collect would work in order to make the asynchronous computation possible in a distributed fashion. Since random access memory is a bottleneck in any application I suggest to put the original memcached paper on our reading list.

One last point to mention is that both systems still don’t seem to be useful as a technology to built a distributed graph data base which enables online query processing.

If you like this post, you might like these related posts:

  1. From Graph (batch) processing towards a distributed graph data base Yesterdays meeting of the reading club was quite nice. We...
  2. Claudio Martella talks @ FOSDEM about Apache Giraph: Distributed Graph Processing in the Cloud Claudio Martella introduces Apache Giraph which according to him is a loose implementation...
  3. Some thoughts on Google Mapeduce and Google Pregel after our discussions in the Reading Club The first meeting of our reading club was quite a success....
  4. PhD proposal on distributed graph data bases Over the last week we had our off campus meeting...
  5. Related work of the Reading club on distributed graph data bases (Beehive, Scalable SPARQL Querying of Large RDF Graphs, memcached) Today we finally had our reading club and discussed several...

Sharing:

Tags: , , , , , , , ,

4 Comments on Google Pregel vs Signal Collect for distributed Graph Processing – pros and cons

  1. [...] Google Pregel vs Signal Collect for distributed Graph Processing – pros and cons [...]

  2. Stefan says:

    My suggestions what to read next:

    CHALLENGES IN PARALLEL GRAPH PROCESSING:
    http://www.google.de/url?sa=t&.....7oHJPWl58w

    And we should take a look at the stuff of the boost people:
    http://www.boost.org/doc/libs/.....index.html
    http://www.boost.org/doc/libs/.....index.html

  3. [...] memcached paper: To understand how for distributed shared memory works which could essentially speed up approaches like Signal Collect [...]

  4. Philip Stutz says:

    That was a very interesting read, thank you for the analysis and comparison. A few comments about Signal/Collect (I am one of the authors of the paper):

    “From here the authors say that one can get rid of the superstep model and make the entire calculation asynchronous. This is done by introducing randomization on the set of vertices on which signal and collect computations have to be computed (as long as the threshold scores are overcome)”

    The execution in one example is random to illustrate that the asynchronous execution gives no guarantees about the execution order. In practice we use different heuristics (above-average, eager) to determine in which order to execute the signal/collect operations. The randomness is just used to explain/argue the absent guarantees; it is not actually implemented that way.
    Sorry for not explaining this better in the paper.

    “I personally understand that Signal Collect can only send signals from one vertex to another if an edge exists and is also not able to add or remove edges or vertices.”

    It is possible to modify the graph even during computations (https://github.com/uzh/signal-collect/blob/master/src/main/scala/com/signalcollect/GraphEditor.scala). Modifying the graph can be problematic, because concurrent modifications introduce nondeterminism.
    You can also send messages without edges, but it is a slight violation of the programming model and should mainly be done to save memory.

    “I wonder how an integration of memcached to Signal/Collect would work in order to make the asynchronous computation possible in a distributed fashion.”

    The architecture of Signal/Collect is based on message passing, so we are using the Akka actor framework for distribution. This should be more efficient than remote reads.

Leave a Reply

*

Close

Subscribe to my newsletter

You don't like mail?