[Paper Review] Parallel Triangles Counting Using Pipelining

Julián Aráoz, Cristina Zoltán|arXiv (Cornell University)|Oct 12, 2015

Graph Theory and Algorithms15 references3 citations

TL;DR

This paper presents a pipelined, architecture-agnostic parallel algorithm for counting triangles in large graphs that do not fit in main memory, using NiMo—a graphical, implicitly functional dataflow programming language. By dynamically scheduling processors based on neighbor set sizes and avoiding high replication via a streaming pipeline, the method achieves efficient, scalable triangle counting without the communication overhead of MapReduce, with correctness preserved even on a single processor.

ABSTRACT

The generalized method to have a parallel solution to a computational problem, is to find a way to use Divide & Conquer paradigm in order to have processors acting on its own data and therefore all can be scheduled in parallel. MapReduce is an example of this approach: Input data is transformed by the mappers, in order to feed the reducers that can run in parallel. In general this schema gives efficient problem solutions, but it stops being true when the replication factor grows. We present another program schema that is useful for describing problem solutions, that can exploit dynamic pipeline parallelism without having to deal with replica- tion factors. We present the schema in an example: counting triangles in graphs, in particular when the graph do not fit in memory. We describe the solution in NiMo, a graphical programming language that implements the implicitly functional parallel data ow model of computation. The solution obtained using NiMo, is architecture agnostic and can be deployed in any parallel/distributed architecture adapting dynamically the processor usage to input characteristics.

Motivation & Objective

• To address the scalability limitations of MapReduce-based triangle counting in large-scale graphs with high replication factors.
• To design a parallel algorithm that efficiently handles graphs too large to fit in memory by leveraging streaming and pipelining.
• To enable dynamic load balancing across processors based on the size of each node's neighbor set, avoiding static partitioning.
• To develop a solution that is both correct on single processors and highly parallelizable across distributed or multicore architectures.
• To provide an architecture-agnostic implementation using NiMo’s implicitly functional dataflow model, supporting deployment on diverse parallel systems.

Proposed method

• The algorithm uses a pipelined dataflow model where each processor acts as a filter responsible for a node, processing incoming edges and maintaining a set of adjacent nodes.
• It employs a dynamic scheduling strategy that assigns each node as a 'responsible' node only if it has not been claimed by a higher-priority neighbor, reducing redundant computation.
• The pipeline operates in two phases: first, collecting adjacent edges per responsible node; second, checking for closing edges to form triangles, with results aggregated across filters.
• The method replaces MapReduce’s hashing-based shuffling with a streaming, message-passing pipeline that minimizes data replication and communication cost.
• The implementation uses NiMo’s process abstraction to model filters as stateful processes that adapt behavior based on input volume and data arrival patterns.
• The algorithm supports error resilience by allowing retryable processes and can be extended to handle multigraphs by using multisets instead of sets for edge counts.

Experimental results

Research questions

• RQ1 How can triangle counting be efficiently parallelized in large graphs that do not fit in main memory?
• RQ2 Can a pipelined dataflow model outperform traditional MapReduce-based approaches in terms of communication cost and load balancing?
• RQ3 How can dynamic load balancing be achieved in triangle counting without prior knowledge of graph structure or static partitioning?
• RQ4 To what extent can a functional, architecture-agnostic programming model like NiMo express scalable and correct parallel algorithms for graph problems?
• RQ5 Can the same algorithm be correct and efficient both in single-processor and highly parallel execution environments?

Key findings

• The proposed pipelined algorithm avoids the high replication factor of MapReduce by using a dynamic, responsibility-based assignment of nodes, reducing intermediate data volume.
• The method achieves correct triangle counting by ensuring each triangle is counted exactly once, with each triangle’s contribution assigned to a single responsible node.
• The algorithm exhibits wavefront-like behavior under the BSP model without barriers, enabling efficient synchronization and load balancing.
• The solution is correct even when executed on a single processor, demonstrating its robustness and correctness across execution scales.
• The architecture-agnostic nature of the NiMo-based implementation allows deployment on diverse parallel and distributed systems with automatic adaptation to input characteristics.
• The approach supports extensions to multigraphs by replacing sets with multisets, enabling counting of repeated triangles with multiplicity-aware closing edge checks.