From ef493d09a3bd3c22d4ae46a8df4a9a9c85492797 Mon Sep 17 00:00:00 2001
From: Apostolof <apotwohd@gmail.com>
Date: Wed, 3 Oct 2018 23:42:01 +0300
Subject: [PATCH] Implement parallel openmp algorithm

---
 openmp/Makefile                               |   4 +-
 openmp/coo_sparse_matrix.c                    |  17 +-
 openmp/coo_sparse_matrix.h                    |  27 +++
 openmp/coo_sparse_matrix.o                    | Bin 4096 -> 0 bytes
 openmp/csr_sparse_matrix.c                    |  17 +-
 openmp/csr_sparse_matrix.h                    |  27 ++-
 openmp/csr_sparse_matrix.o                    | Bin 3192 -> 0 bytes
 openmp/openmp_gs_pagerank.c                   |  65 +++++++
 ...tions.c => openmp_gs_pagerank_functions.c} | 184 +++++++++++-------
 ...tions.h => openmp_gs_pagerank_functions.h} |  18 +-
 openmp/pagerank.out                           | Bin 28459 -> 0 bytes
 openmp/serial_gs_pagerank.c                   |  44 -----
 openmp/serial_gs_pagerank.o                   | Bin 3456 -> 0 bytes
 openmp/serial_gs_pagerank_functions.o         | Bin 18752 -> 0 bytes
 14 files changed, 262 insertions(+), 141 deletions(-)
 delete mode 100644 openmp/coo_sparse_matrix.o
 delete mode 100644 openmp/csr_sparse_matrix.o
 create mode 100644 openmp/openmp_gs_pagerank.c
 rename openmp/{serial_gs_pagerank_functions.c => openmp_gs_pagerank_functions.c} (75%)
 rename openmp/{serial_gs_pagerank_functions.h => openmp_gs_pagerank_functions.h} (86%)
 delete mode 100644 openmp/pagerank.out
 delete mode 100644 openmp/serial_gs_pagerank.c
 delete mode 100644 openmp/serial_gs_pagerank.o
 delete mode 100644 openmp/serial_gs_pagerank_functions.o

diff --git a/openmp/Makefile b/openmp/Makefile
index 2e297ea..a810950 100644
--- a/openmp/Makefile
+++ b/openmp/Makefile
@@ -7,8 +7,8 @@ CC = gcc -std=gnu99 -fopenmp
 RM = rm -f
 CFLAGS_DEBUG=-O0 -ggdb3 -Wall -I.
 CFLAGS=-O3 -Wall -I.
-OBJ=serial_gs_pagerank.o serial_gs_pagerank_functions.o coo_sparse_matrix.o csr_sparse_matrix.o
-DEPS=serial_gs_pagerank_functions.h coo_sparse_matrix.h csr_sparse_matrix.h
+OBJ=openmp_gs_pagerank.o openmp_gs_pagerank_functions.o coo_sparse_matrix.o csr_sparse_matrix.o
+DEPS=openmp_gs_pagerank_functions.h coo_sparse_matrix.h csr_sparse_matrix.h
 
 # ==========================================
 # TARGETS
diff --git a/openmp/coo_sparse_matrix.c b/openmp/coo_sparse_matrix.c
index 93d0ac9..689a0fe 100644
--- a/openmp/coo_sparse_matrix.c
+++ b/openmp/coo_sparse_matrix.c
@@ -15,9 +15,8 @@ void allocMemoryForCoo(CooSparseMatrix *sparseMatrix, int numberOfElements) {
 }
 
 void addElement(CooSparseMatrix *sparseMatrix, double value, int row, int column) {
+	// Checks if there is enough space allocated
 	if (sparseMatrix->numberOfNonZeroElements == sparseMatrix->size) {
-		printf("%d == %d |||| %d, %d\n", sparseMatrix->numberOfNonZeroElements,
-			sparseMatrix->size, row, column);
 		printf("Number of non zero elements exceeded size of matrix!\n");
 		exit(EXIT_FAILURE);
 	}
@@ -29,6 +28,7 @@ void addElement(CooSparseMatrix *sparseMatrix, double value, int row, int column
 	newElement->rowIndex = row;
 	newElement->columnIndex = column;
 
+	// Adds the new element to the first empty (NULL) address of the matrix
 	sparseMatrix->elements[sparseMatrix->numberOfNonZeroElements] = newElement;
 	sparseMatrix->numberOfNonZeroElements = sparseMatrix->numberOfNonZeroElements + 1;
 }
@@ -42,14 +42,19 @@ void transposeSparseMatrix(CooSparseMatrix *sparseMatrix) {
 	}
 }
 
+/*
+ * This function is a port of the one found here:
+ * https://github.com/scipy/scipy/blob/3b36a57/scipy/sparse/sparsetools/coo.h#L34
+*/
 void transformToCSR(CooSparseMatrix initialSparseMatrix,
 	CsrSparseMatrix *transformedSparseMatrix) {
-	// Taken from here: https://github.com/scipy/scipy/blob/3b36a57/scipy/sparse/sparsetools/coo.h#L34
-	if (initialSparseMatrix.numberOfNonZeroElements > transformedSparseMatrix->size) {
+	// Checks if the sizes of the two matrices fit
+	if (initialSparseMatrix.numberOfNonZeroElements > transformedSparseMatrix->numberOfElements) {
 		printf("Transformed CSR matrix does not have enough space!\n");
 		exit(EXIT_FAILURE);
 	}
 
+	// Calculates the elements per row
 	for (int i=0; i<initialSparseMatrix.numberOfNonZeroElements; ++i){
 		int rowIndex = initialSparseMatrix.elements[i]->rowIndex;
 		transformedSparseMatrix->rowCumulativeIndexes[rowIndex] = 
@@ -63,6 +68,7 @@ void transformToCSR(CooSparseMatrix initialSparseMatrix,
 		sum += temp;
 	}
 
+	// Copies the values and columns of the elements
 	for (int i=0; i<initialSparseMatrix.numberOfNonZeroElements; ++i){
 		int row  = initialSparseMatrix.elements[i]->rowIndex;
 		int destinationIndex = transformedSparseMatrix->rowCumulativeIndexes[row];
@@ -73,13 +79,12 @@ void transformToCSR(CooSparseMatrix initialSparseMatrix,
 		transformedSparseMatrix->rowCumulativeIndexes[row]++;
 	}
 
+	// Fixes the cumulative sum
 	for (int i=0, last=0; i<=transformedSparseMatrix->size; i++){
 		int temp = transformedSparseMatrix->rowCumulativeIndexes[i];
 		transformedSparseMatrix->rowCumulativeIndexes[i] = last;
 		last = temp;
 	}
-
-	transformedSparseMatrix->numberOfNonZeroElements = initialSparseMatrix.numberOfNonZeroElements;
 }
 
 void cooSparseMatrixVectorMultiplication(CooSparseMatrix sparseMatrix,
diff --git a/openmp/coo_sparse_matrix.h b/openmp/coo_sparse_matrix.h
index dd4c31d..0a34b7e 100644
--- a/openmp/coo_sparse_matrix.h
+++ b/openmp/coo_sparse_matrix.h
@@ -1,6 +1,8 @@
 #ifndef COO_SPARSE_MATRIX_H	/* Include guard */
 #define COO_SPARSE_MATRIX_H
 
+/* ===== INCLUDES ===== */
+
 #include <stdbool.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -8,26 +10,51 @@
 
 #include "csr_sparse_matrix.h"
 
+/* ===== STRUCTURES ===== */
+
+// One element of the coordinate formated sparse matrix.
 typedef struct cooSparseMatrixElement {
 	double value;
 	int rowIndex, columnIndex;
 } CooSparseMatrixElement;
 
+// A sparse matrix in COOrdinate format (aka triplet format).
 typedef struct cooSparseMatrix {
 	int size, numberOfNonZeroElements;
 	CooSparseMatrixElement **elements;
 } CooSparseMatrix;
 
+/* ===== FUNCTION DEFINITIONS ===== */
+
+// initCooSparseMatrix creates and initializes the members of a CooSparseMatrix
+// structure instance.
 CooSparseMatrix initCooSparseMatrix();
+
+//allocMemoryForCoo allocates memory for the elements of the matrix.
 void allocMemoryForCoo(CooSparseMatrix *sparseMatrix, int numberOfElements);
+
+// addElement adds an element representing the triplet passed in the arguments
+// to the first empty address of the space allocated for the elements.
 void addElement(CooSparseMatrix *sparseMatrix, double value, int row,
 	int column);
+
+// transposeSparseMatrix transposes the matrix.
 void transposeSparseMatrix(CooSparseMatrix *sparseMatrix);
+
+// transformToCSR transforms the sparse matrix representation format from COO
+// to CSR.
 void transformToCSR(CooSparseMatrix initialSparseMatrix,
 	CsrSparseMatrix *transformedSparseMatrix);
+
+// cooSparseMatrixVectorMultiplication calculates the product of a
+// CooSparseMatrix and a vector.
 void cooSparseMatrixVectorMultiplication(CooSparseMatrix sparseMatrix,
 	double *vector, double **product, int vectorSize);
+
+// destroyCooSparseMatrix frees all space used by the CooSparseMatrix.
 void destroyCooSparseMatrix(CooSparseMatrix *sparseMatrix);
+
+// printCooSparseMatrix prints the values of a CooSparseMatrix.
 void printCooSparseMatrix(CooSparseMatrix sparseMatrix);
 
 #endif	// COO_SPARSE_MATRIX_H
\ No newline at end of file
diff --git a/openmp/coo_sparse_matrix.o b/openmp/coo_sparse_matrix.o
deleted file mode 100644
index 8b80d4e77349e7a99abd331292352e4fbfe21943..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4096
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
NLYo2~i{SEo{157s#?$}+

diff --git a/openmp/csr_sparse_matrix.c b/openmp/csr_sparse_matrix.c
index bdf8413..65e200a 100644
--- a/openmp/csr_sparse_matrix.c
+++ b/openmp/csr_sparse_matrix.c
@@ -3,7 +3,7 @@
 CsrSparseMatrix initCsrSparseMatrix() {
 	CsrSparseMatrix sparseMatrix;
 	sparseMatrix.size = 0;
-	sparseMatrix.numberOfNonZeroElements = 0;
+	sparseMatrix.numberOfElements = 0;
 
 	sparseMatrix.values = NULL;
 	sparseMatrix.columnIndexes = NULL;
@@ -11,21 +11,23 @@ CsrSparseMatrix initCsrSparseMatrix() {
 	return sparseMatrix;
 }
 
-void allocMemoryForCsr(CsrSparseMatrix *sparseMatrix, int numberOfElements) {
+void allocMemoryForCsr(CsrSparseMatrix *sparseMatrix, int size, int numberOfElements) {
 	sparseMatrix->values = (double *) malloc(numberOfElements * sizeof(double));
 	sparseMatrix->columnIndexes = (int *) malloc(
 		numberOfElements * sizeof(int));
 	sparseMatrix->rowCumulativeIndexes = (int *) malloc(
-		(numberOfElements + 1) * sizeof(int));
+		(size + 1) * sizeof(int));
 
-	for (int i=0; i<numberOfElements+1; ++i) {
+	for (int i=0; i<size+1; ++i) {
 		sparseMatrix->rowCumulativeIndexes[i] = 0;
 	}
-	sparseMatrix->size = numberOfElements;
+
+	sparseMatrix->size = size;
+	sparseMatrix->numberOfElements = numberOfElements;
 }
 
-// Row indexes start from 0!
 void zeroOutRow(CsrSparseMatrix *sparseMatrix, int row) {
+	// Gets start and end indexes of the row's elements
 	int startIndex = sparseMatrix->rowCumulativeIndexes[row],
 	endIndex = sparseMatrix->rowCumulativeIndexes[row+1];
 	for (int i=startIndex; i<endIndex; ++i) {
@@ -34,9 +36,8 @@ void zeroOutRow(CsrSparseMatrix *sparseMatrix, int row) {
 }
 
 void zeroOutColumn(CsrSparseMatrix *sparseMatrix, int column) {
-	for (int i=0; i<sparseMatrix->numberOfNonZeroElements; ++i){
+	for (int i=0; i<sparseMatrix->numberOfElements; ++i){
 		if(sparseMatrix->columnIndexes[i] == column){
-			// Zeros out this element
 			sparseMatrix->values[i] = 0;
 		}
 	}
diff --git a/openmp/csr_sparse_matrix.h b/openmp/csr_sparse_matrix.h
index a964514..5588e9a 100644
--- a/openmp/csr_sparse_matrix.h
+++ b/openmp/csr_sparse_matrix.h
@@ -1,24 +1,47 @@
 #ifndef CSR_SPARSE_MATRIX_H	/* Include guard */
 #define CSR_SPARSE_MATRIX_H
 
+/* ===== INCLUDES ===== */
+
 #include <stdbool.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+/* ===== STRUCTURES ===== */
+
+// A sparse matrix in compressed SparseRow format.
 typedef struct csrSparseMatrix {
-	int size, numberOfNonZeroElements;
+	int size, numberOfElements;
 	int *rowCumulativeIndexes, *columnIndexes;
 	double *values;
 } CsrSparseMatrix;
 
+/* ===== FUNCTION DEFINITIONS ===== */
+
+// initCsrSparseMatrix creates and initializes the members of a CsrSparseMatrix
+// structure instance.
 CsrSparseMatrix initCsrSparseMatrix();
-void allocMemoryForCsr(CsrSparseMatrix *sparseMatrix, int numberOfElements);
+
+// allocMemoryForCsr allocates memory for the elements of the matrix.
+void allocMemoryForCsr(CsrSparseMatrix *sparseMatrix, int size, int numberOfElements);
+
+// zeroOutRow assigns a zero value to all the elements of a row in the matrix.
 void zeroOutRow(CsrSparseMatrix *sparseMatrix, int row);
+
+// zeroOutColumn assigns a zero value to all the elements of a column in the
+// matrix.
 void zeroOutColumn(CsrSparseMatrix *sparseMatrix, int column);
+
+// csrSparseMatrixVectorMultiplication calculates the product of a
+// CsrSparseMatrix and a vector.
 void csrSparseMatrixVectorMultiplication(CsrSparseMatrix sparseMatrix,
 	double *vector, double **product, int vectorSize);
+
+// destroyCsrSparseMatrix frees all space used by the CsrSparseMatrix.
 void destroyCsrSparseMatrix(CsrSparseMatrix *sparseMatrix);
+
+// printCsrSparseMatrix prints the values of a CsrSparseMatrix.
 void printCsrSparseMatrix(CsrSparseMatrix sparseMatrix);
 
 #endif	// CSR_SPARSE_MATRIX_H
\ No newline at end of file
diff --git a/openmp/csr_sparse_matrix.o b/openmp/csr_sparse_matrix.o
deleted file mode 100644
index c5872b439d8077c33563caffdd2443694f24642e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3192
zcmbtWUu;ul6#v>@SQ+!SQ%q{ma388}DmN?aVFSe7tz);O69Ow^G8o<6ZPw5~OM9yu
z!Y0;Dn@eFYzUhPd!W#)Okr#A-kS>~#IehV7f&>HwjE+D^B*AmO`+cL_Z7+I~@1Aph
z=kNEo9cc}3b2=P^lY?v}k2H=Fa#?sJH&L;PJV7dnTDV`TK)uvPJ=9X08&%+5#(l`A
zJ?q{<u5^U8-y(&(yVb%!+lyPSAr_jv>b!wMxNu!9wD_nTDjx9*pn0h_dK*OdV0AI#
z2;5T(C3W(O6;gP4-+rZgI_6pT9%dk_+38lbd#Wa!F+0u(jk8CeQ_UT|+9?Q|yy8-e
zTPA-;Kkk2LI))^3-Ru-b=Z0T`7;j+W=BjZuKjCPc8h)m+{#fo#*lhEKO2PytunZ&D
ztpp44N+eXct8_$gero=fdvq>n_WA2nGvRL-u2#*hsy1h}Lg&>wdUbdx=IQ(?Y<BpY
zRMYUQfrl|q%_ZKCss+yxv*R4h#ArL(mH)#5)^BR3+Ka-wYO(4<xLEZeE_`4DmLLdg
zsjVUN9<QK4e?qu%X5P~!T$=anoylDbnXO=|uDY-0OAe*+!N_N7{=6HPPuUL(So7`8
zUt;65Z*#=j1J!)nP1^*)yN|A$(y8oGBCUbjbdLF3J~QawshZvXy`vL_AnsVV-|aau
z3@y=qRP%`69W2~zHigs8X2)sVkuIEPKUxkdh3{cXsy3t4p0Aw>7wa#Ei(5{rj_=fB
z;-cHLj<lK;^NPp2GFbSv@Z*=b@L%EaJd2-D{({wBC|?pnjeq9mLiw*9!N!DN7<nJ&
z=CkIe98h|ucctHw_C4RXU+Rx$Eg^MS(i3`8PZ`-wQl%6%BrToDB~#QZo|WE=CUUy;
zs`PwJswAYXrDc;;6Y0&RjGR<2H^}wtH{_@m7!K6Sb@lSbS_{V>30Y$?;yApEI0n6r
zwN(}FacCMZ#k0&-%Xkg&Iwp4_Zx+4Bok7tz=4uh8yx`m}`V`UIEV`}uZsxmzam+cu
z<c*9s0Jm-gA#~XwXVKXz`i{F4Q5q8zu_nKwO{{Z%QYqE|qKH25fD+1Tf){pz<&ls>
z@x1d5EKlHwk)II*I*T8OI_Yc{eJ5PaqEr-G#hT+Q6tQk>r6M-uD}v%q=SN}#08kJd
zz|ks0<m^z=i1q?EG8XUWQbtciWkVk{h};)7qD1b^W{I3hqk`@Mxq--9I*EHn<W$<w
z<+j%&>$65wI|P0ht@roDGSQ@t9sVzpAR5owN?VpDrk`>?Zos`Lr?sHq{j}2zoGBzX
zCI?y#14Ue8B>HFqe*p&KE*Rx>!&aBuSURqfS3ts?|1~}Uv6z#eH4rKB`mb?-ao#`g
zqX}@7`T1sU<VDsH_E%0kj`I*0xm@nI+dd&?wEG@l@%H7~%i<+l0PmmI>H=Y@{hP%N
z13G0fx_=nU<N5wo1GZGFgDh!3i|5SN4xPKbcl4E5q020w3b0i$?DY{_sy_U5Q#x<4
zg|EH-g25)BpFsY8XoIQhqFpbxxR&k&(4|%w`(Cj)2_P;)|8Xp`xfW*sxXHEX_7d_m
zxI9_bCx45PBhJq&eUAa#48wl60V2)I;32><&p0{(@%z&OGUBroC4|4%y$tuV4WMr}
zU}M~$;S%UbAH!IxpHBhD{C_cj`bGox#WMax%Vv7A1JO)Y?@30DOngw*NIVrcTC$nl
z6mF*|i6#<htzA#1Geg_b8L*Nhg-B9QW_5!c)-&lHIRk!Yx!6K~PO(6FqCL81q%-Zg
zgb^P|#I>jqPp3$q4$pde$X+v+(RDJAiKiBI)6+xYSdZ3!2xbQV1?ZO$yeoJ$A3U@u
zvJ9>*gC8lw@lNqPo7s9|{&M_>G92$Z_rJ0Xp27q`c>T&x_c4YedkO~6^Et>!_PV#0
u$uCiF%b%sBNWBfOWBNfG&d;l1!})prz=rel%HI*JiDQ=aciHC8&*i@xdkho+

diff --git a/openmp/openmp_gs_pagerank.c b/openmp/openmp_gs_pagerank.c
new file mode 100644
index 0000000..17a4e66
--- /dev/null
+++ b/openmp/openmp_gs_pagerank.c
@@ -0,0 +1,65 @@
+#include <sys/time.h>
+
+#include "openmp_gs_pagerank_functions.h"
+
+struct timeval startwtime, endwtime;
+
+int main(int argc, char **argv) {
+	CsrSparseMatrix transitionMatrix = initCsrSparseMatrix();
+	double *pagerankVector;
+	bool convergenceStatus;
+	Parameters parameters;
+	int maxIterationsForConvergence = 0;
+
+	parseArguments(argc, argv, &parameters);
+
+	initialize(&transitionMatrix, &pagerankVector, &parameters);
+
+	// Saves information about the dataset to the output file
+	{
+		FILE *outputFile;
+		outputFile = fopen(parameters.outputFilename, "w");
+
+		if (outputFile == NULL) {
+			printf("Error while opening the output file.\n");
+			exit(EXIT_FAILURE);
+		}
+
+		fprintf(outputFile, "Pagerank will run for the dataset %s\n"\
+			"Dataset contains %d pages with %d outlinks.\n",
+			parameters.graphFilename, parameters.numberOfPages, transitionMatrix.size);
+
+		fclose(outputFile);
+	}
+
+	// Starts wall-clock timer
+	gettimeofday (&startwtime, NULL);
+	int* iterations = (int *)malloc(parameters.numberOfPages*sizeof(int));
+
+	// Calculates pagerank
+	iterations = pagerank(&transitionMatrix, &pagerankVector,
+		&convergenceStatus, parameters, &maxIterationsForConvergence);
+
+	// Stops wall-clock timer
+	gettimeofday (&endwtime, NULL);
+	double seq_time = (double)((endwtime.tv_usec - startwtime.tv_usec)/1.0e6 +
+		endwtime.tv_sec - startwtime.tv_sec);
+	printf("%s wall clock time = %f\n","Pagerank (Gauss-Seidel method), serial implementation",
+		seq_time);
+
+	printf(ANSI_COLOR_YELLOW "\n----- RESULTS -----\n" ANSI_COLOR_RESET);
+	if (convergenceStatus) {
+		printf(ANSI_COLOR_GREEN "Pagerank converged after %d iterations!\n" \
+			ANSI_COLOR_RESET, maxIterationsForConvergence);
+	} else {
+		printf(ANSI_COLOR_RED "Pagerank did not converge after max number of" \
+			" iterations (%d) was reached!\n" ANSI_COLOR_RESET, maxIterationsForConvergence);
+	}
+
+	// Saves results to the output file
+	savePagerankToFile(parameters.outputFilename, iterations, pagerankVector,
+		parameters.numberOfPages, maxIterationsForConvergence);
+
+	free(pagerankVector);
+	destroyCsrSparseMatrix(&transitionMatrix);
+}
diff --git a/openmp/serial_gs_pagerank_functions.c b/openmp/openmp_gs_pagerank_functions.c
similarity index 75%
rename from openmp/serial_gs_pagerank_functions.c
rename to openmp/openmp_gs_pagerank_functions.c
index cb406c1..4d24b17 100644
--- a/openmp/serial_gs_pagerank_functions.c
+++ b/openmp/openmp_gs_pagerank_functions.c
@@ -1,12 +1,13 @@
 /* ===== INCLUDES ===== */
 
-#include "serial_gs_pagerank_functions.h"
-#include <omp.h>
+#include "openmp_gs_pagerank_functions.h"
+
 /* ===== CONSTANTS ===== */
 
 const char *ARGUMENT_CONVERGENCE_TOLERANCE = "-c";
 const char *ARGUMENT_MAX_ITERATIONS = "-m";
 const char *ARGUMENT_DAMPING_FACTOR = "-a";
+const char *ARGUMENT_THREADS_NUMBER = "-t";
 const char *ARGUMENT_VERBAL_OUTPUT = "-v";
 const char *ARGUMENT_OUTPUT_HISTORY = "-h";
 const char *ARGUMENT_OUTPUT_FILENAME = "-o";
@@ -15,26 +16,31 @@ const int NUMERICAL_BASE = 10;
 char *DEFAULT_OUTPUT_FILENAME = "pagerank_output";
 const int FILE_READ_BUFFER_SIZE = 4096;
 
-const int CONVERGENCE_CHECK_ITERATION_PERIOD = 3;
-const int SPARSITY_INCREASE_ITERATION_PERIOD = 3;
+const int CONVERGENCE_CHECK_ITERATION_PERIOD = 2;
+const int SPARSITY_INCREASE_ITERATION_PERIOD = 10;
+
+/* ===== GLOBAL VARIABLES ====== */
+
+int numberOfThreads;
 
 /* ===== FUNCTIONS ===== */
 
-int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
-	bool *convergenceStatus, Parameters parameters) {
+int* pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
+	bool *convergenceStatus, Parameters parameters, int* maxIterationsForConvergence) {
 	// Variables declaration
-	int iterations = 0, numberOfPages = parameters.numberOfPages;
+	int numberOfPages = parameters.numberOfPages;
+	int *iterations;
 	double delta, *pagerankDifference, *previousPagerankVector,
 	*convergedPagerankVector, *linksFromConvergedPagesPagerankVector;
+	CsrSparseMatrix originalTransitionMatrix = initCsrSparseMatrix();
 	CooSparseMatrix linksFromConvergedPages = initCooSparseMatrix();
 	bool *convergenceMatrix;
 
-	int P = omp_get_max_threads();
-	omp_set_num_threads(P);
-	
 	// Space allocation
 	{
 		size_t sizeofDouble = sizeof(double);
+		// iterations until each page converged
+		iterations = (int *) malloc(numberOfPages * sizeof(int));
 		// pagerankDifference used to calculate delta
 		pagerankDifference = (double *) malloc(numberOfPages * sizeofDouble);
 		// previousPagerankVector holds last iteration's pagerank vector
@@ -50,12 +56,22 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 		*convergenceStatus = false;
 
 		// Initialization
-		allocMemoryForCoo(&linksFromConvergedPages, transitionMatrix->numberOfNonZeroElements);
-		#pragma omp parallel for num_threads(P)
+		// originalTransitionMatrix used to run pagerank in phases
+		allocMemoryForCsr(&originalTransitionMatrix, transitionMatrix->size, transitionMatrix->numberOfElements);
+		memcpy(originalTransitionMatrix.rowCumulativeIndexes, transitionMatrix->rowCumulativeIndexes,
+			(transitionMatrix->size+1) * sizeof(int));
+		memcpy(originalTransitionMatrix.columnIndexes, transitionMatrix->columnIndexes,
+			transitionMatrix->numberOfElements * sizeof(int));
+		memcpy(originalTransitionMatrix.values, transitionMatrix->values,
+			transitionMatrix->numberOfElements * sizeof(double));
+
+		allocMemoryForCoo(&linksFromConvergedPages, transitionMatrix->numberOfElements);
+		#pragma omp parallel for num_threads(numberOfThreads)
 		for (int i=0; i<numberOfPages; ++i) {
 			convergedPagerankVector[i] = 0;
 			convergenceMatrix[i] = false;
 			linksFromConvergedPagesPagerankVector[i] = 0;
+			iterations[i] = 0;
 		}
 	}
 
@@ -66,7 +82,7 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 	do {
 		// Stores previous pagerank vector
 		memcpy(previousPagerankVector, *pagerankVector, numberOfPages * sizeof(double));
-		
+
 		// Calculates new pagerank vector
 		calculateNextPagerank(transitionMatrix, previousPagerankVector,
 			pagerankVector, linksFromConvergedPagesPagerankVector,
@@ -75,14 +91,14 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 
 		if (parameters.history) {
 			// Outputs pagerank vector to file
-			savePagerankToFile(parameters.outputFilename, iterations != 0,
-				*pagerankVector, numberOfPages, parameters.realIterations);
+			savePagerankToFile(parameters.outputFilename, NULL, *pagerankVector,
+				numberOfPages, *maxIterationsForConvergence);
 		}
 
 		// Periodically checks for convergence
-		if (!(iterations % CONVERGENCE_CHECK_ITERATION_PERIOD)) {
+		if (!((*maxIterationsForConvergence) % CONVERGENCE_CHECK_ITERATION_PERIOD)) {
 			// Builds pagerank vectors difference
-			#pragma omp parallel for num_threads(P)
+			#pragma omp parallel for num_threads(numberOfThreads)
 			for (int i=0; i<numberOfPages; ++i) {
 				pagerankDifference[i] = (*pagerankVector)[i] - previousPagerankVector[i];
 			}
@@ -95,11 +111,13 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 			}
 		}
 
+		++(*maxIterationsForConvergence);
+
 		// Periodically increases sparsity
-		if (iterations && !(iterations % SPARSITY_INCREASE_ITERATION_PERIOD)) {
+		if ((*maxIterationsForConvergence) && !(*maxIterationsForConvergence % SPARSITY_INCREASE_ITERATION_PERIOD)) {
 			bool *newlyConvergedPages = (bool *) malloc(numberOfPages * sizeof(bool));
 			// Checks each individual page for convergence
-			#pragma omp parallel for num_threads(P)
+			#pragma omp parallel for num_threads(numberOfThreads)
 			for (int i=0; i<numberOfPages; ++i) {
 				double difference = fabs((*pagerankVector)[i] -
 					previousPagerankVector[i]) / fabs(previousPagerankVector[i]);
@@ -110,9 +128,11 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 					newlyConvergedPages[i] = true;
 					convergenceMatrix[i] = true;
 					convergedPagerankVector[i] = (*pagerankVector)[i];
+					iterations[i] = *maxIterationsForConvergence;
 				}
 			}
-			#pragma omp parallel for num_threads(P)
+
+			#pragma omp parallel for num_threads(numberOfThreads)
 			for (int i=0; i<numberOfPages; ++i) {
 				// Filters newly converged pages
 				if (newlyConvergedPages[i] == true) {
@@ -132,10 +152,10 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 						}
 					}
 
-					// Increases sparsity of the transition matrix by
-					// deleting elements that correspond to converged pages
+					// Increases sparsity of the transition matrix by zeroing
+					// out elements that correspond to converged pages
 					zeroOutRow(transitionMatrix, i);
-					zeroOutColumn(transitionMatrix, i);
+					//zeroOutColumn(transitionMatrix, i);
 
 					// Builds the new linksFromConvergedPagesPagerankVector
 					cooSparseMatrixVectorMultiplication(linksFromConvergedPages,
@@ -146,21 +166,29 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 			free(newlyConvergedPages);
 		}
 
-		++iterations;
+		// Prunes the transition matrix every 8 iterations
+		if (*maxIterationsForConvergence != 0 && (*maxIterationsForConvergence%8 == 0)) {
+			memcpy(transitionMatrix->values, originalTransitionMatrix.values,
+				transitionMatrix->numberOfElements * sizeof(double));
+			#pragma omp parallel for num_threads(numberOfThreads)
+			for (int i=0; i<numberOfPages; ++i) {
+				convergedPagerankVector[i] = 0;
+				convergenceMatrix[i] = false;
+				linksFromConvergedPagesPagerankVector[i] = 0;
+			}
+			linksFromConvergedPages.numberOfNonZeroElements = 0;
+		}
+
 		// Outputs information about this iteration
-		if (iterations%2) {
-			printf(ANSI_COLOR_BLUE "Iteration %d: delta = %f\n" ANSI_COLOR_RESET, iterations, delta);
-		} else {
-			printf(ANSI_COLOR_CYAN "Iteration %d: delta = %f\n" ANSI_COLOR_RESET, iterations, delta);
+		if (parameters.verbose){
+			if ((*maxIterationsForConvergence)%2) {
+				printf(ANSI_COLOR_BLUE "Iteration %d: delta = %f\n" ANSI_COLOR_RESET, *maxIterationsForConvergence, delta);
+			} else {
+				printf(ANSI_COLOR_CYAN "Iteration %d: delta = %f\n" ANSI_COLOR_RESET, *maxIterationsForConvergence, delta);
+			}
 		}
 	} while (!*convergenceStatus && (parameters.maxIterations == 0 ||
-		iterations < parameters.maxIterations));
-	parameters.realIterations = iterations;
-	if (!parameters.history) {
-		// Outputs last pagerank vector to file
-		savePagerankToFile(parameters.outputFilename, false, *pagerankVector,
-			numberOfPages, parameters.realIterations);
-	}
+		*maxIterationsForConvergence < parameters.maxIterations));
 
 	// Frees memory
 	free(pagerankDifference);
@@ -169,7 +197,7 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 	free(linksFromConvergedPagesPagerankVector);
 	free(convergenceMatrix);
 	destroyCooSparseMatrix(&linksFromConvergedPages);
-	
+
 	return iterations;
 }
 
@@ -181,6 +209,9 @@ int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
 void initialize(CsrSparseMatrix *transitionMatrix,
 	double **pagerankVector, Parameters *parameters) {
 
+	// Sets the number of threads to be used
+	omp_set_num_threads(numberOfThreads);
+
 	// Reads web graph from file
 	if ((*parameters).verbose) {
 		printf(ANSI_COLOR_YELLOW "----- Reading graph from file -----\n" ANSI_COLOR_RESET);
@@ -190,7 +221,8 @@ void initialize(CsrSparseMatrix *transitionMatrix,
 	// Outputs the algorithm parameters to the console
 	if ((*parameters).verbose) {
 		printf(ANSI_COLOR_YELLOW "\n----- Running with parameters -----\n" ANSI_COLOR_RESET\
-			"Number of pages: %d", (*parameters).numberOfPages);
+			"Number of pages: %d"\
+			"\nNumber of threads: %d", (*parameters).numberOfPages, numberOfThreads);
 		if (!(*parameters).maxIterations) {
 			printf("\nMaximum number of iterations: inf");
 		} else {
@@ -201,7 +233,7 @@ void initialize(CsrSparseMatrix *transitionMatrix,
 			"\nGraph filename: %s\n", (*parameters).convergenceCriterion,
 			(*parameters).dampingFactor, (*parameters).graphFilename);
 	}
-	(*parameters).realIterations = 0;
+
 	// Allocates memory for the pagerank vector
 	(*pagerankVector) = (double *) malloc((*parameters).numberOfPages * sizeof(double));
 	double webUniformProbability = 1. / (*parameters).numberOfPages;
@@ -221,24 +253,22 @@ void calculateNextPagerank(CsrSparseMatrix *transitionMatrix,
 	double *linksFromConvergedPagesPagerankVector,
 	double *convergedPagerankVector, int vectorSize, double dampingFactor) {
 	// Calculates the web uniform probability once.
-	
-	
 	double webUniformProbability = 1. / vectorSize;
 
 	csrSparseMatrixVectorMultiplication(*transitionMatrix, previousPagerankVector,
 		pagerankVector, vectorSize);
-	#pragma omp parallel for
+
+	#pragma omp parallel for num_threads(4)
 	for (int i=0; i<vectorSize; ++i) {
 		(*pagerankVector)[i] = dampingFactor * (*pagerankVector)[i];
 	}
 
 	double normDifference = vectorNorm(previousPagerankVector, vectorSize) -
 	vectorNorm(*pagerankVector, vectorSize);
-	#pragma omp parallel for
+
 	for (int i=0; i<vectorSize; ++i) {
-		//(*pagerankVector)[i] += normDifference * webUniformProbability +
-		//linksFromConvergedPagesPagerankVector[i] + convergedPagerankVector[i];
-		(*pagerankVector)[i] += 0.5*normDifference* webUniformProbability +linksFromConvergedPagesPagerankVector[i] + convergedPagerankVector[i];
+		(*pagerankVector)[i] += normDifference * webUniformProbability +
+		linksFromConvergedPagesPagerankVector[i] + convergedPagerankVector[i];
 	}
 }
 
@@ -261,13 +291,15 @@ double vectorNorm(double *vector, int vectorSize) {
  * parseArguments parses the command line arguments given by the user.
 */
 void parseArguments(int argumentCount, char **argumentVector, Parameters *parameters) {
-	if (argumentCount < 2 || argumentCount > 10) {
+	if (argumentCount < 2 || argumentCount > 16) {
 		validUsage(argumentVector[0]);
 	}
 
+	numberOfThreads = omp_get_max_threads();
+
 	(*parameters).numberOfPages = 0;
 	(*parameters).maxIterations = 0;
-	(*parameters).convergenceCriterion = 1;
+	(*parameters).convergenceCriterion = 0.001;
 	(*parameters).dampingFactor = 0.85;
 	(*parameters).verbose = false;
 	(*parameters).history = false;
@@ -304,6 +336,15 @@ void parseArguments(int argumentCount, char **argumentVector, Parameters *parame
 				exit(EXIT_FAILURE);
 			}
 			(*parameters).dampingFactor = alphaInput;
+		} else if (!strcmp(argumentVector[argumentIndex], ARGUMENT_THREADS_NUMBER)) {
+			argumentIndex = checkIncrement(argumentIndex, argumentCount, argumentVector[0]);
+
+			size_t threadsInput = strtol(argumentVector[argumentIndex], &endPointer, NUMERICAL_BASE);
+			if (threadsInput == 0 && endPointer) {
+				printf("Invalid iterations argument\n");
+				exit(EXIT_FAILURE);
+			}
+			numberOfThreads = threadsInput;
 		} else if (!strcmp(argumentVector[argumentIndex], ARGUMENT_VERBAL_OUTPUT)) {
 			(*parameters).verbose = true;
 		} else if (!strcmp(argumentVector[argumentIndex], ARGUMENT_OUTPUT_HISTORY)) {
@@ -423,33 +464,27 @@ void generateNormalizedTransitionMatrixFromFile(CsrSparseMatrix *transitionMatri
 
 	// Calculates the outdegree of each page and assigns the uniform probability
 	// of transition to the elements of the corresponding row
-
 	int* pageOutdegree = malloc((*parameters).numberOfPages*sizeof(int));
 	for (int i=0; i<(*parameters).numberOfPages; ++i){
 		pageOutdegree[i] = 0;
 	}
 
-	
 	for (int i=0; i<numberOfEdges; ++i) {
 		int currentRow = tempMatrix.elements[i]->rowIndex;
-
-				if (currentRow == tempMatrix.elements[i]->rowIndex) {
-					++pageOutdegree[currentRow];
-				} 
-	
-			
+		++pageOutdegree[currentRow];
 	}
 
 	for (int i=0; i<tempMatrix.size; ++i) {
 		tempMatrix.elements[i]->value = 1./pageOutdegree[tempMatrix.elements[i]->rowIndex];
 	}
-	
+	free(pageOutdegree);
+
 	// Transposes the temporary transition matrix (P^T).
 	transposeSparseMatrix(&tempMatrix);
-	allocMemoryForCsr(transitionMatrix, numberOfEdges);
+
+	allocMemoryForCsr(transitionMatrix, (*parameters).numberOfPages, numberOfEdges);
 	// Transforms the temporary COO matrix to the desired CSR format
 	transformToCSR(tempMatrix, transitionMatrix);
-	//printCsrSparseMatrix(*transitionMatrix);
 	destroyCooSparseMatrix(&tempMatrix);
 
 	fclose(graphFile);
@@ -486,27 +521,34 @@ int checkIncrement(int previousIndex, int maxIndex, char *programName) {
 	return ++previousIndex;
 }
 
-void savePagerankToFile(char *filename, bool append, double *pagerankVector,
-	int vectorSize, int realIterations) {
+void savePagerankToFile(char *filename, int *iterationsUntilConvergence,
+	double *pagerankVector, int vectorSize, int iteration) {
 	FILE *outputFile;
 
-	if (append) {
-		outputFile = fopen(filename, "a");
-	} else {
-		outputFile = fopen(filename, "w");
-	}
+	outputFile = fopen(filename, "a");
 
 	if (outputFile == NULL) {
 		printf("Error while opening the output file.\n");
 		return;
 	}
-	//Save numberofPages and convergence time
-	
+
+	fprintf(outputFile, "\n----- Iteration %d -----\n", iteration);
+
+	// Saves the pagerank vector
+	double sum = 0;
 	for (int i=0; i<vectorSize; ++i) {
-		fprintf(outputFile, "%f ", pagerankVector[i]);
+		sum += pagerankVector[i];
 	}
-	fprintf(outputFile, "\n");
-	//fprintf(outputFile, "%d\t", vectorSize);
-	//fprintf(outputFile, "%d\t", realIterations);
+	if (iterationsUntilConvergence == NULL){
+		for (int i=0; i<vectorSize; ++i) {
+			fprintf(outputFile, "%d = %.10g\n", i, pagerankVector[i]/sum);
+		}
+	} else {
+		for (int i=0; i<vectorSize; ++i) {
+			fprintf(outputFile, "%d\t%d\t%.10g\n", i, iterationsUntilConvergence[i],
+				pagerankVector[i]/sum);
+		}
+	}
+
 	fclose(outputFile);
 }
\ No newline at end of file
diff --git a/openmp/serial_gs_pagerank_functions.h b/openmp/openmp_gs_pagerank_functions.h
similarity index 86%
rename from openmp/serial_gs_pagerank_functions.h
rename to openmp/openmp_gs_pagerank_functions.h
index 658ce9a..d7c12db 100644
--- a/openmp/serial_gs_pagerank_functions.h
+++ b/openmp/openmp_gs_pagerank_functions.h
@@ -1,5 +1,5 @@
-#ifndef SERIAL_GS_PAGERANK_FUNCTIONS_H	/* Include guard */
-#define SERIAL_GS_PAGERANK_FUNCTIONS_H
+#ifndef OPENMP_GS_PAGERANK_FUNCTIONS_H	/* Include guard */
+#define OPENMP_GS_PAGERANK_FUNCTIONS_H
 
 /* ===== INCLUDES ===== */
 
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
+#include <omp.h>
 
 #include "coo_sparse_matrix.h"
 
@@ -27,6 +28,7 @@
 extern const char *ARGUMENT_CONVERGENCE_TOLERANCE;
 extern const char *ARGUMENT_MAX_ITERATIONS;
 extern const char *ARGUMENT_DAMPING_FACTOR;
+extern const char *ARGUMENT_THREADS_NUMBER;
 extern const char *ARGUMENT_VERBAL_OUTPUT;
 extern const char *ARGUMENT_OUTPUT_HISTORY;
 extern const char *ARGUMENT_OUTPUT_FILENAME;
@@ -41,7 +43,7 @@ extern const int FILE_READ_BUFFER_SIZE;
 
 // A data structure to conveniently hold the algorithm's parameters.
 typedef struct parameters {
-	int numberOfPages, maxIterations, realIterations;
+	int numberOfPages, maxIterations;
 	double convergenceCriterion, dampingFactor;
 	bool verbose, history;
 	char *outputFilename, *graphFilename;
@@ -71,8 +73,8 @@ void generateNormalizedTransitionMatrixFromFile(CsrSparseMatrix *transitionMatri
 
 // Function savePagerankToFile appends or overwrites the pagerank vector
 // "pagerankVector" to the file with the filename supplied in the arguments.
-void savePagerankToFile(char *filename, bool append, double *pagerankVector,
-	int vectorSize, int realIterations);
+void savePagerankToFile(char *filename, int *iterationsUntilConvergence,
+	double *pagerankVector, int vectorSize, int iteration);
 
 // Function initialize allocates memory for the pagerank vector, reads the
 // dataset from the file and creates the transition probability distribution
@@ -92,7 +94,7 @@ void calculateNextPagerank(CsrSparseMatrix *transitionMatrix,
 // Function pagerank iteratively calculates the pagerank of each page until
 // either the convergence criterion is met or the maximum number of iterations
 // is reached.
-int pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
-	bool *convergenceStatus, Parameters parameters);
+int* pagerank(CsrSparseMatrix *transitionMatrix, double **pagerankVector,
+	bool *convergenceStatus, Parameters parameters, int* maxIterationsForConvergence);
 
-#endif	// SERIAL_GS_PAGERANK_FUNCTIONS_H
\ No newline at end of file
+#endif	// OPENMP_GS_PAGERANK_FUNCTIONS_H
\ No newline at end of file
diff --git a/openmp/pagerank.out b/openmp/pagerank.out
deleted file mode 100644
index 37ff79d49f942d0c283a294b8594d6e676621673..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 28459
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

diff --git a/openmp/serial_gs_pagerank.c b/openmp/serial_gs_pagerank.c
deleted file mode 100644
index 3836cf8..0000000
--- a/openmp/serial_gs_pagerank.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <sys/time.h>
-#include <omp.h>
-#include "serial_gs_pagerank_functions.h"
-//#include "coo_sparse_matrix.h"
-
-struct timeval startwtime, endwtime;
-double seq_time;
-
-int main(int argc, char **argv) {
-	CsrSparseMatrix transitionMatrix = initCsrSparseMatrix();
-	double *pagerankVector;
-	bool convergenceStatus;
-	Parameters parameters;
-	omp_set_dynamic(0);
-	parseArguments(argc, argv, &parameters);
-
-	initialize(&transitionMatrix, &pagerankVector, &parameters);
-
-	// Starts wall-clock timer
-	gettimeofday (&startwtime, NULL);
-
-	int iterations = pagerank(&transitionMatrix, &pagerankVector,
-		&convergenceStatus, parameters);
-	if (parameters.verbose) {
-		printf(ANSI_COLOR_YELLOW "\n----- RESULTS -----\n" ANSI_COLOR_RESET);
-		if (convergenceStatus) {
-			printf(ANSI_COLOR_GREEN "Pagerank converged after %d iterations!\n" \
-				ANSI_COLOR_RESET, iterations);
-		} else {
-			printf(ANSI_COLOR_RED "Pagerank did not converge after max number of" \
-				" iterations (%d) was reached!\n" ANSI_COLOR_RESET, iterations);
-		}
-	}
-
-	// Stops wall-clock timer
-	gettimeofday (&endwtime, NULL);
-	double seq_time = (double)((endwtime.tv_usec - startwtime.tv_usec)/1.0e6 +
-		endwtime.tv_sec - startwtime.tv_sec);
-	printf("%s wall clock time = %f\n","Pagerank (Gauss-Seidel method), serial implementation",
-		seq_time);
-
-	free(pagerankVector);
-	destroyCsrSparseMatrix(&transitionMatrix);
-}
diff --git a/openmp/serial_gs_pagerank.o b/openmp/serial_gs_pagerank.o
deleted file mode 100644
index 366656bad738e1327246669f577a5f563a5691df..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3456
zcmbtWQEMDk6uz5{Hb%R<ty&{dn99Z`nhcpF4@I$VNZK7WYUm~qiS07kxtkrcGqcXj
zwn+>&r9rZUKoJD-$)BL$LlLnlRS=&FzV*fWB8nmy&=(8woICgK-kr_7=z*Pc&Ue0Z
z?zwmGy)#$N&YbH?B#4j%IYU~WKnb~*Y}q+x=17JdCH;%z<96=|igNyJVSZ+=pfInu
ze{s|%7$37|jb-W?&WciUolDePrlw+)1L`RQrec9M0?T#$lRSl0hdiy7XIiG>xIr_Y
zr`yJ=;?(UWsN|NVO3L7XIiy@Re8r<isY1<G>1Hc~d86+8BL!-iw5r%NsJQ0Pu;NqC
zGOCJY*Q(T}PQY3t13px%R+UoKEv+blWmDxPWuV+k$h@|vH~uO#{?V`gegit!cQ>-L
zzu*+K1E%!dxok~u{L%PPa(9EQE;0YUi3wqRXBy~`lh>Ohz0sZ30bkV{)7c(<XDho2
zbaXQ4Y;&g%o$K6D(D|4<gXnz9ol!Q<=2whL>g$>``o5li?kMnxzViT6&olKU+F#@2
zChiSn?cHEj`XVFjrx$KDbNAD4-{N!G$m*fhTowK5H@HmN-r|MZjoYlIw#TZ5ZEa-p
zq;a=?qBWYf$0EPZ9UL5VqGtfb#!xo5)Jc+`ntDMQoL{OtL0y?pPpcCnV|C_f?`sq4
z=!7~x6yhxBG4>=Rv3{N;Rx^qIM~?Jdhp7z%{uGaG;Z!G6nGd?orTVTVUrF6bBu^!J
zQ+-pZ%w(!(@?qqu{+b;aOP~WU)D>X`bTuHVX#@sQmwcb7o{J7LHT876tAR_ahKe~r
zFub5%YcfiH0Q8b;<IW^1oCvDs-<Tf(UTK9V(n_)H88+p;|6kP)1#tQgMhfL3zHpH%
z%Smt$ldcaI&ar3bBbt8-C_V7|ule{tV$Cu5$&%yF&oT%$j)fxnc#+%D{AW4gNyctH
zM4r%Z^8AkV;{>+1TIq17w#%#FcDF;!%dkyH$U;{bOo75NME`vuOfG=Np^kH3sPA~5
z;0s*%Lcaq6%pVm5uJ7=CTwhtlyoL55C~TQ`pXbXM+EMN{$2#bIL+FtLqHh6T1LLsu
ztFUX15V20Uez>F}U*N|8i|##uh|a+e(UBzDKl&ZL19tC7m{jAzG`QGObo_?^J8b+}
zc=w>Nt2s2;GdjK$YBQ17P5x}&opLbQ@h^nY<e@Xc{toL9@xxXgarV-Xhh%oL<CYQQ
zidAV(NfN#Y?J(5mheN_oFgvaeu5!EJy?0#dN1Rgy@aP%E%!wF$ItDMq;1>ZuM)nWH
z7(!by{7W(Tm6$r)G5n8W@K0j!&v|{ZqC%7K1FE>}7i;{hPc0F3W@?<+hUE~;v4Sbz
zE7T0nr>`4<XRQ*~t`&V66wNiqu&okdu}N>aj;}eNrNB3twN43pAzsGsFS1Mn)Na`{
z)*vJNz$DZ$!*H=!^DHMQ7fY2DQuZh%CWZH{yA~bXr|%Y7L6{IoxKF|}i+93(_`X1S
znngn#&#J)1{fEaG|0{v#z(zqF?+}6K5d^`VE8od83=R2@f-U%8NH~702>e@)W1Yvj
zjp}=D<G6C2A0!<4qR!n2E>7%E5{`WeT)Z!FTs*~}ao%rSBQC$|y7+~J{ott-<EAAX
z>kGV3!tuWl_%jmzgoF=EINsTU|1!r#pAcg5n#7muzZKyxa6XOUyAi&^`R~Q>MI6_G
IU;QlOUp7|u&;S4c

diff --git a/openmp/serial_gs_pagerank_functions.o b/openmp/serial_gs_pagerank_functions.o
deleted file mode 100644
index 6e91ac740e531c407f846b1524581cbd678197cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 18752
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