OPTIMIZATION OF THE FUNCTIONAL DECOMPOSITION

OF PARALLEL AND DISTRIBUTED COMPUTATIONS IN

GRAPH COLORING WITH THE USE OF HIGH-
PERFORMANCE COMPUTING

ASSIGNMENT REPORT
Submitted by
VISWAVANI H (422421104048)
SANDHIYA S (422421104301)

BACHELOR OF ENGINEERING
IN
COMPUTER SCIENCE AND ENGINEERING
Third Year

UNIVERSITY COLLEGE OF ENGINEERING

TINDIVANAM
( A Constituent College of Anna University)

1
ABSTRACT:
This contribution addresses the challenge of efficiently computing proper edge coloring
for a large set of graphs, focusing on cubic graphs, on HPC systems. Proper edge coloring is
crucial for various applications including graph analysis, scheduling, and compilation, and
poses an NP-complete problem. Despite its simplicity, edge coloring for cubic graphs remains
NP-complete. This paper presents a novel method for optimal decomposition of the problem
to minimize computational time through parallel computations. The method achieves two
objectives: dividing graphs into subsets for efficient edge coloring order determination, and
ensuring uniform computational time across all graphs. Extensive experiments validate the
proposed method on large datasets. The motivation behind parallel methods is to create
computational grains suitable for any system, leading to overall computational time reduction.
The paper discusses related research, load balancing, theoretical analysis, and presents
algorithms for edge coloring. Conclusions highlight future work for time reduction through
parallel and distributed computing.

INTRODUCTION:
When designing and implementing massive computing applications for HPC systems,
it is necessary to take into account the appropriate allocation of tasks on computing resources.
At the same time, it is necessary to decompose the computation so that the individual subtasks
of the computation are processed in the similar (in an ideal case equal) time. In this
contribution, we compute the proper edge coloring of a large set of graphs (up to 404 million
graphs) on an HPC system. Proper edge coloring of cubic graphs is a problem that is frequently
computed as part of gaining knowledge concerning graph data and properties of graphs, in
scheduling, in register allocation done as a part of source code translation and compilation, as
well as in pattern matching problems. In these problems, the algorithm needs to color many
graphs, which represents an NP-complete problem. In this work we will work with cubic
graphs - graphs with all vertices of degree 3 - which represent the simplest (nontrivial) instance
of the problem of edge coloring of graphs. The associate editor coordinating the review of this
manuscript and approving it for publication was Thomas Canhao Xu. Although we are working
with the simplest instance of the edge coloring problem, in the authors proved that it is still an
NP-complete problem. The novel method presented in this article ensures the optimal
decomposition of the problem in the design and implementation of parallel computations to
minimize the computational time of edge coloring of a sizable set of graphs. This method
consists of meeting two objectives which ensure considerable parallel speedup of computation
of given problem - 3-edge coloring of set of graphs. The first objective is to divide the set of
graphs into subsets (clusters) so that for each subset of graphs, it is possible to find the order
2
of edge coloring, which reduces the required time to compute each graph in the subset.

EDGE BACKTRACKING ALGORITHM:

This section introduces the sequential algorithm based on breadth-first search, which is
called the edge backtracking algorithm. The edge backtracking algorithm works based on the
edge coloring of graphs with predetermined successions of three colors. In this case, when the
algorithm finds a conflict in the coloring of the graph, it backtracks to the previous edge,
recolors the edge and continues coloring. If there are no possible proper colorings of the
problematic edge, the algorithm further backtracks to the edge that precedes both recolored
edges. The algorithm continues in this approach until either the whole graph is properly
colored or until the algorithm examines all possible edge coloring methods of a given graph.
The time complexity of the edge backtracking algorithm is O(2 n−1 ), where n is the number
of vertices of a given graph.
1)The algorithm itself is represented in the following steps:
the graph is colored properly, or there is conflict in the graph coloring.
2) In the case of conflict in the coloring of graph, the algorithm backtracks to edges that were
already colored and recolors them using the next color in predetermined succession of colors
until either of the following occurs:
the conflict is solved, –where in this case, the algorithm can continue coloring more edges of
the graph, as stated in the first step of the algorithm, or all possibilities of edge coloring of the
graph are improper, where in this case, the colored graph is snark (cubic graph that cannot be
properly colored using three colors).
The algorithm is used in parallel parts of all proposed methods in later sections of this paper.

DESCRIPTION:
Efficient computation of proper edge coloring for a vast array of graphs, particularly
focusing on cubic graphs, poses a significant challenge, especially when leveraging high-
performance computing (HPC) systems. Proper edge coloring is indispensable in various
domains, spanning from graph analysis to scheduling and compilation, yet it remains a
notoriously NP-complete problem. Despite its apparent simplicity, the complexity inherent in
edge coloring for cubic graphs persists, presenting a formidable obstacle to timely solutions.
In response to this challenge, this paper introduces a novel method designed to address the
computational burden associated with proper edge coloring, specifically tailored for HPC
systems. The key objective of this method is twofold: first, to optimize the decomposition of
3
the problem, thereby minimizing computational time through parallel computations; second,
to divide graphs into subsets strategically, facilitating efficient determination of edge coloring
order while ensuring uniform computational time across all graphs. Extensive experimentation
validates the efficacy of the proposed method on large datasets, demonstrating its practical
utility and performance. At the core of this approach lies the motivation to harness parallel
methods, aiming to create computational grains adaptable to diverse systems, ultimately
leading to a reduction in overall computational time. Throughout the paper, discussions
encompass a range of pertinent topics, including related research, load balancing strategies,
theoretical analysis, and detailed algorithms for edge coloring. Such comprehensive coverage
enriches the understanding of the proposed method's context, significance, and potential
implications. In conclusion, the paper not only presents a solution to the immediate challenge
of efficient proper edge coloring but also lays the groundwork for future endeavors. By
highlighting avenues for further time reduction through parallel and distributed computing, the
paper sets a forward-looking trajectory, underscoring the commitment to continual
advancement in this domain.

MODELS OF PARALLEL COMPUTATIONS FOR EDGE COLORING OF

GRAPHS:
In the examination of graph properties, the edge coloring of the graph is partial
operation. Thus, we must reduce the computational time of edge coloring. In and, we showed
that one graph can be colored at different times if we color it in different orders of edges. In
the whole paper, we use the label permutation of graph as this changed order of edge coloring.
In the algorithms in sections VII - IX, we work with the concept of coloring permuted cubic
graphs—graphs with identical structures but different orders of edges. The permutation of
graphs is based on a simple matrix multiplication in relation 3. Let graph G be represented by
adjacency matrix A. We must create a large number of permutations of adjacency matrix A;
therefore, we create a number of modifications of one graph with different orders of edge We
use graph automorphism. Let graph G’ be automorphic to a given graph G. An important
property of automorphic graphs is that any arbitrary pair of such graphs is described by
different adjacency matrices but can be presented as the same diagram with different
(displaced) labelling of edges and vertices. In our case, this means that we work with the same
graphs with different orders of vertices and edges. The permutation of adjacency matrix A of
graph G to create an automorphic graph is computed as follows: A 0 = P −1 ∗ A ∗ P. where A
is the adjacency matrix of given graph G, P is a randomly generated permutation matrix (matrix
containing exactly one value 1 in every row and column), P −1 is transposed permutation
matrix P, and A 0 is the permuted adjacency matrix of graph G. The permuted matrix A’
obtained by this computation represents the changed order of edges of the original graph G.
We use this order (permutation) in our algorithms for edge coloring.
4
ALGORITHM:
Functional Decomposition Based on Graph Clustering:
Require: N, P
k = 0 repeat
k++
PBEST = Pk
in parallel do
use edgeBacktracking to color graphs from N while using PBEST
if coloringTime(Gn) < 1 ms then add Gn to cluster Ck remove Gn from N
end if remove PBEST from P pair PBEST with cluster Ck
end parallelism
until N is empty

Algorithm Of Functional Decomposition Based On Clustering:

This part of the paper contains an algorithm of functional decomposition based on
clustering (AFDC). To examine objective 1 and objective 2, we designed an algorithm of
functional decomposition based on clustering. The input datasets of the algorithm are the
following:
Input set of graphs N stored in graph6 format—a– memory-friendly format to store graphs
encrypted in vectors. Set of permutations P. We chose a set of 500 permutations computed in
previous experiments in. These permutations were chosen based on the computational time of
edge coloring, which was the shortest. The chosen permutations are sorted in ascending order
of computational time of coloring, where the first permutation corresponds to best (fastest)
order of edges for edge coloring.
The algorithms of functional decomposition based on clustering work as follows:
1) Choose the permutation with the lowest time of coloring from set P and label it PBEST
. Apply this permutation to the input set of graphs N and edge color this permuted set in
parallel using the edge backtracking algorithm.
2) Check the chosen time constraint for every graph in the set. The constraint is designed
as follows: Was graph G edge colored in less than one millisecond?
TRUE: Graph G is allocated to cluster Ck and removed from set N. FALSE: The
algorithm continues with the next step without any action.
5
 3) Permutation PBEST is allocated to cluster Ck and removed from set P
4) If some graphs remain in set N, the algorithm creates new clusters and cycles back to
step 1 of this algorithm. If the set of graphs N is empty, i.e., all graphs were colored in
less than one millisecond, the algorithm stops.
The output of the algorithm is a set of k files; –each file contains a cluster of graphs colored
in under one millisecond and a permutation, which was applied on each graph in the cluster to
reach this time of edge coloring.

Schematic of the algorithm based on graph clustering:

6
CONCLUSION:
This paper addresses the challenge of efficiently computing proper edge coloring for a
significant number of graphs, with a specific focus on cubic graphs, utilizing High-
Performance Computing (HPC) systems. Proper edge coloring is essential for various
applications, ranging from graph analysis to scheduling and compilation, yet it remains an NP-
complete problem, especially for cubic graphs. The presented approach introduces a novel
method for optimal problem decomposition, aiming to minimize computational time through
parallel computations. This method accomplishes two key objectives: firstly, dividing graphs
into subsets to facilitate efficient determination of edge coloring order, and secondly, ensuring
uniform computational time distribution across all graphs. Extensive experimental validation
on large datasets underscores the efficacy of the proposed method. The motivation behind
employing parallel methods is to establish computational grains adaptable to any system,
thereby reducing overall computational time. Furthermore, the paper discusses related
research, load balancing techniques, and provides theoretical analysis, along with presenting
algorithms tailored for edge coloring.

REFERENCES:
[1] D. Marx, ‘‘Graph colouring problems and their applications in scheduling,’’
Periodica Polytechnica Elect. Eng., vol. 48, nos. 1-2, pp. 11–16, 2004.
[2] G. J. Chaitin, ‘‘Register allocation & spilling via graph coloring,’’ in Proc.
SIGPLAN Symp. Compiler Construct. (SIGPLAN), 1982, pp. 98–105. [3] L.
Kowalik, ‘‘Improved edge-coloring with three colors,’’ Theor. Comput. Sci., vol.
410, nos. 38–40, pp. 3733–3742, Sep. 2009

**************************