projet-programmation-imperative/doc/rapport.tex

\documentclass[a4paper]{article}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{graphicx}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{color}
\usepackage[french]{babel}
\usepackage{hyperref}

\usepackage{minted}
%\usemintedstyle{borland}
\newminted{ada}{linenos, numbersep=6pt, frame=leftline, xleftmargin=6mm, firstnumber=last}
\newminted{bash}{numbersep=6pt, frame=leftline, xleftmargin=6mm}

\usepackage[
    top=1.5cm,
    bottom=1.5cm,
    left=1.5cm,
    right=1.5cm
]{geometry}

\begin{document}

\begin{figure}[t]
    \centering
    \includegraphics[width=5cm]{inp_n7.png}
\end{figure}

\title{\vspace{4cm} \textbf{Rapport de projet de programmation impérative} \\ Implémentation d'un algorithme de pageRank \vspace{1cm}}
\author{Maxime Dubaux \\ Laurent Fainsin}
\date{\vspace{7cm} Département Sciences du Numérique - Première année \\
2020 - 2021 }

\maketitle

\newpage
\tableofcontents

\newpage

\section{Introduction}

Lors de ce projet nous avons implémenté un algorithme permettant de caculer le PageRank pour un réseau donné.
Nous l'avons construit à partir de la methode des raffinages. De même, nous utilisons le langage de programmation compilé Ada.

\section{Résumé du sujet}

Le PageRank est un algorithme d'analyse des liens entre des pages Web dans un réseau, il mesure la popularité des pages dans celui-ci. En outre il trie les pages internet de la plus populaire à la moins populaire selon des principes simples:

\begin{itemize}
    \item Une page est respectable si d'autre page la reference, et d'autant plus si elle meme sont populaire.
    \item Néanmois il faut ajuster la popularité selon la page qui reference, plus une page possède de lien vers d'autres sites, moins ses référencements ont de valeur.
\end{itemize}

\begin{figure}[ht!]
    \centering
    \includegraphics[width=10cm]{PageRanks-Example.jpg}
    \caption{Exemple d'un réseau et de ses poids calculés via le pageRank \cite{wiki_pageRank}. \label{fig : ex_pageRank}}
\end{figure}

À l'aide du théoreme de point fixe, il peut se résume en un calcul répété d'un produit vecteur-matrice.

Toute la difficulté provient de la taille massive que peut avoir le réseau. Il faut donc choisir les bonnes de structures de données. Cet algorithme est notamment utilisé par le moteur de recherche Google qui estime son propre réseaux à une cinquantaine de milliards de pages.

\section{Architecture du programme}

Nous pouvons diviser notre programme en trois sous-parties qui s'occuperons de gérer les différents type ainsi que la bonne execution du programme. De même, mise à part pour la récupération des arguments dans la ligne de commande, nous adopterons un style de programmation offensif puisque l'utilisateur n'intéragit jamais avec le programme.

\subsection{Gestion des vecteurs}

Ada est un langage fortement typé, comme nous manipulons ici plusieurs types de données, il est logique de créer un type "Vector" générique dont l'unique but sera de stocker des informations. Nous aurons aussi besoin à plusieurs moments lors du calcul du pagerank de trier, sommer, initialiser des Vectors, d'où le choix de placer cette structure de données dans son propre module. \\

Lorsque nous trierons les données nous ferons appelle à l'algorithme QuickSort. \\

Nous avons choisi de séparer les vecteurs d'entiers des vecteurs de flottants, car créer un seul et unique module permettant la gestion d'entiers ou de flottants était trop compliqué. Le code aurait été plus compliqué à lire. Nous avons alors choisi de séparer comme ceci le code, bien que cela produise du code un peu redondant.

\subsection{Formatage du code}

Nous avons choisis d'utiliser des "declare" plutot que des sous-procédures dont on ferait l'appelle puisque cela permet d'avoir un lecture plus linéaire du code.

\subsection{Gestion des matrice de Google}

Nous devrons regrouper dans des modules génériques le code en rapport avec la gestion des matrices de Google. Nous pourrons deux module, un gérant les matrices naives et un autre pour gérer les matrices creuses. 
Ces modules introduirons le type T\_Google, ainsi que des procédure et fonctions permettant de générer la matrice G, nécéssaire au calcul du pageRank, mais aussi l'opération de multiplication entre un vecteur et une matrice.

\subsection{Gestion du calcul du Pagerank}

Cette dernière partie s'occupe de regrouper tous les éléments présents dans les deux modules cités précédemment pour ainsi calculer itérativement le pageRank du réseaux. Cette sous-partie gère de plus le traitement des arguments de la ligne de commande ainsi que la lecture et l'écriture des résultats dans des fichiers.

\section{Structures de données}

Nous avons besoin d'une structure pour stocker le poids de chaque pages (i.e. sa popularité), nous appellerons cette structure "pi".
De même, nous avons besoin d'une structure pour stocker le réseau "network" décrivant les liens entre chaque pages du réseau.
Enfin il nous faudra créer une structure de données adapté à notre utilisation pour stocker la matrice de Google, notée G.

Nous connaissons à l'avance les tailles des différentes structures, car le réseau est connu. Il n'est donc pas nécéssaire de créer des types dynamiques (i.e. liste chainées, vecteurs à taille variable stockés dans le heap...), un simple stockage statique dans le stack suffit.

Notons N le nombre de pages dans le réseau, et N\_Links le nombre de liens total dans le réseau.

Ainsi pour stocker pi, nous choissons la structure d'un vecteur statique (array) de dimension 1xN.

De même, pour stocker network nous choisissons la structure d'un vecteur de T\_Links de dimension 1xN\_Links (avec T\_Links un enregistrement permettant le stocker les informations d'un liens).

Pour stocker G, la matrice de Google, nous avons 2 choix:
\begin{itemize}
    \item Une Matrice naive
    \item Une Matrice creuse (éventuellement compressée)
\end{itemize}

\subsection{Implémentation Naive}
Le premier choix consiste à stocker la matrice très naivement, c'est-à-dire en stockant l'ensemble de ses valeurs dans une matrice de taille NxN.

L'avantage principale de cette structure est que sa construction et sa manipulation (produit vecteur-matrice) est simple.
Pour la construire à partir du réseau nous assignons à chaque lien une valeur dans la matrice. De même celle-ci à l'avantage d'être robuste par défaut à la présence de doublons dans le réseau.

L'inconvénient est que nous stockons beaucoups de valeurs inutiles (i.e. des éléments qui se répètent ou bien qui sont égaux à 0). Ainsi puisqu'un produit vecteur-matrice est de compléxité N\^2, nous perdons beaucoup de temps à effectuer des opérations inutiles.

\subsection{Implémentation Creuse}
Il faut alors nous orienter vers une autre solution si l'on souhaite être plus efficace.

Pour alléger la taille mémoire de la matrice G, nous pouvons la rendre creuse, c'est-à-dire de ne pas stocker les valeurs nulles de celle-ci.

Cependant nous pouvons aller encore plus loin en compressant G via un algorithme de compression simple appelé CSR \cite{wiki_CSR}.

De cette manière nous ne gardons que les informations qui sont essentielles.

L'inconvénient de cette méthode est que la création de ce type de matrice et son utilisation est plus compliqué que pour une matrice naive.

Mais l'avantage de cette structure de donnée est son gain d'espace non négligeable ainsi que la rapidité qu'elle propose. En effet, nous n'effectuons plus que N\_Links opérations lors du produit vecteur-matrice, au lieu de N**2 pour la version naive. De même nous, nous stockons uniquement des entiers dans G, au lieu de nombres flottants pour la version naive.

\section{Benchmark}

Voici l'ensemble des tests réalisés avec la commande time et valgrind sur l'ordinateur c202-02 de l'ENSEEIHT.

La commande suivante a été éxécutée pour élargir la taille maximale du stack:
\begin{bashcode}
$ ulimit -s unlimited
\end{bashcode}

Valgrind génère une sortie similaire à celle-ci pour l'ensemble des programmes:
\begin{bashcode}
HEAP SUMMARY:
    in use at exit: 0 bytes in 0 blocks
    total heap usage: 22 allocs, 22 frees, 27,308 bytes allocated

All heap blocks were freed -- no leaks are possible

ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
\end{bashcode}

Comme le heap n'est pas utilisé par le programme (mis à part pour quelques variables dont nous n'avons pas le controle direct), sachant le PID du programme, nous pouvons inspecter le fichier suivant pour connaitre la taille qu'occupe le programme dans le stack:

\begin{bashcode}
$ build/pagerank fichiers_test/Exemple_sujet/exemple_sujet.net -n & { while [[ -f /proc/$!/smaps ]]; do grep -A 1 stack /proc/$!/smaps >> stack.txt; done } ; tail stack.txt
\end{bashcode}



\subsection{Version Naive}

\subsubsection{exemple\_sujet.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Exemple_sujet/exemple_sujet.net -n
real	0m0,009s
user	0m0,000s
sys	 0m0,006s
\end{bashcode}

\subsubsection{worm.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Worm/worm.net -n
real	0m0,073s
user	0m0,061s
sys	 0m0,009s
\end{bashcode}

\subsubsection{brainlinks.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Brainlinks/brainlinks.net -n
real	2m41,387s
user	2m41,074s
sys	 0m0,280s
\end{bashcode}

\subsection{Version Creuse}

\subsubsection{exemple\_sujet.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Exemple_sujet/exemple_sujet.net
real	0m0,168s
user	0m0,001s
sys	 0m0,009s
\end{bashcode}

\subsubsection{worm.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Worm/worm.net
real	0m0,034s
user	0m0,016s
sys	 0m0,004s
\end{bashcode}

\subsubsection{brainlinks.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Brainlinks/brainlinks.net
real	1m55,939s
user	1m55,909s
sys	 0m0,012s
\end{bashcode}

\subsubsection{Linux26.net}
\begin{bashcode}
$ time build/pagerank fichiers_test/Linux26/Linux26.net
real	437m38,234s
user	437m34,783s
sys	 0m0,440s
\end{bashcode}

\section{Conclusion}

Nos programmes ne génèrent aucune erreurs selon valgrind et s'éxecutent pour chacuns des réseaux (mise à part pour Linux26 dans le cas naif, mais cela semble normal au vu de la taille du réseau). \\
On remaque facilement la supériorité temporelle et spatiale de la version creuse contre la version naive, surtout lorsque N et N\_links sont grands.

\subsection{Améliorations encore possible}

Lors de l'implémentation de la matrice compressé, nous avons choisis de compressé les lignes puisque celle-ci peuvent parfois être entièrement vide, cela est bénéfique d'un point de vu espace. Cepedant ils serait aussi intéressant de compresser G selon les colonnes puisque, bien que l'on perde en espace mémoire, on gagnerait en efficacité temporelle grâce au nombre réduit d'accès mémoire que l'on effecturait par rapport à la compression par ligne.

Il est important de noter qu'un compression par colonne permettrait aussi de paralléliser la problème, le rendant encore plus efficace temporellement. Il est assez simple d'implémenter la parallélisation en Ada puisque cette notion fait partie à part entière du langage de programmation, mais nous ne l'avons pas implémenté par manque de temps.

Finalement nous % todo network stack bug

\section{Apports personnels} 

Ce projet nous a permis de solidifer nos connaissances sur les structures de données, car nous avons longuement réfléchi sur lequelles étaient les plus adaptées au problème. De même nous avons eu l'occasion de revoir plusieurs algorithme classique, nous permettant de mieux les maitriser.

\newpage

\begin{thebibliography}{9}
    \bibitem{wiki_pageRank} 
    Wikipedia, PageRank \\
    \href{https://en.wikipedia.org/wiki/PageRank}{https://en.wikipedia.org/wiki/PageRank}
    
    \bibitem{wiki_CSR} 
    Wikipedia, Sparse matrix \\
    \href{https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)}{https://en.wikipedia.org/wiki/Sparse\_matrix\#Compressed\_sparse\_row\_(CSR,\_CRS\_or\_Yale\_format)}

    \bibitem{wiki_ada}
    Wikibooks, Ada Programming \\
    \href{https://en.wikibooks.org/wiki/Ada_Programming}{https://en.wikibooks.org/wiki/Ada\_Programming}

    \bibitem{rosetta_code}
    Rosetta Code, Ada \\
    \href{https://rosettacode.org/wiki/Category:Ada}{https://rosettacode.org/wiki/Category:Ada}
\end{thebibliography}

\end{document}