taf fait

VAISSE_compte_rendu

@@ -0,0 +1,18 @@
+GPROF : FONCTIONNEMENT
+
+Deux métriques sont utilisés lors des mesures : le temps, et le nombre d'appels.
+Dans un premier tableau, dit Flat Profile, il donne la consommation du temps en pourcentage par rapport au temps d'exécution total, ainsi que le nombre d'appels sur ce même temps. Il fait cela en mesurant tous les centièmes de secondes.
+
+D'après ce premier tableau, on constate que le tri bulle consomme nettement plus
+que n'importe quelle autre fonction du programme, avec une consommation d'à peu près 80% du temps total d'exécution. La deuxième fonction consommant le plus est find_rank_student, avec une consommation de 20%.
+
+On a aussi le callgraph, qui permet de hiérarchiser les fonctions selon qui appelle qui, en indiquant le nombre d'appels et les temps d'exécution individuels de chaque sous-fonctions. 
+
+Ici, on voit que la fonction bubblesort est appelé 1 million de fois par find_rank_student; c'est sûrement ce qui pose un problème.
+
+Cela nous permet de voir qu'il y a un appel en trop de bubblesort dans find_rank_student. Une fois retiré, et Gprof relancé, bubblesort n'est appelé plus que mille fois. Mais, l'algorithme reste toujours trop lourd, et continue de consomer près de 80% du temps d'exécution total. En replaçant l'algorithme par un plus optimisé, comme le heapsort, les performances sont largement meilleures. Il n'y a plus qu'une dizaines d'opérations effectuées, et le temps de consommation est quasiment nulle pour toutes les fonctions.
+
+L'ensemble de ces résultats sont valables pour 1000 étudiants et 1000 notes chacuns. Pour 10000 et 10000, même avec un tri par tas, l'exécution consomme bien plus.
+
+
+On va donc devoir changer l'algorithmie.

bubblesort.c

@@ -14,7 +14,7 @@ void bubblesort(int* array, int length)
 				tmp = array[i-1];
 				array[i-1] = array[i];
 				array[i] = tmp;
-				swapped++;
+				swapped=1;
 			}
 		}
 	} while(swapped==1);

student_rank.c

@@ -55,7 +55,7 @@ int find_rank_student(int student_grade, int* grades_array, int students_number)
 {
     int position = -1;
     int i = 0;
-    bubblesort(grades_array,students_number);
+    (grades_array,students_number);
     for(i = students_number-1; i >= 0; i--)
     {
         if(grades_array[i] == student_grade)
@@ -73,16 +73,16 @@ void sort_students(int** students_rank, int** students_array, int students_numbe
     for(i = 0; i < grades_number; i++)
     {
         int * grades = (int*) malloc(students_number*sizeof(int));
-	for(j = 0; j < students_number; j++)
-	{
-	    grades[j] = students_array[j][i];
-	}
-        bubblesort(grades,students_number);
-	for(j = 0; j < students_number; j++)
-	{
-            students_rank[j][i] = find_rank_student(students_array[j][i],grades,students_number);
-	}
-	free(grades);
+    	for(j = 0; j < students_number; j++)
+    	{
+    	    grades[j] = students_array[j][i];
+    	}
+        heapsort(grades,students_number);
+        for(j = 0; j < students_number; j++)
+        {
+                students_rank[j][i] = find_rank_student(students_array[j][i],grades,students_number);
+        }
+        free(grades);
     }
 }
 
@@ -93,6 +93,7 @@ int main(int argc, char** argv)
     int students_length = 0;
     int grades_length = 0;
     int debug_mode = 0;
+    int* ranker = NULL; 
     
     if(argc != 4)
     {