TD1_DEV51_Qualite_Algo/Résultat.txt

J'ai essayé avec 100000 étudiant et 10000 notes sans debug, ça prend beacoup de temps
Ensuite avec 1000 étudiant et 1000 notes, ça prend environ 3 secondes.
Puis avec 5 fois plus d'étudiant, ça prend 1 minutes et 18 secondes.

Avec 1000 étudiants et 1000 notes sans debug on utilise gprof pour le profiling.
On peut voir que les fonctions qui prennent le plus de temps sont find_rank_student et bubblesort avec bubblesort qui prend 81.43 % du temps d'exécution.

 %   cumulative   self              self     total           
 time   seconds   seconds    calls   s/call   s/call  name    
 81.43      2.39     2.39  1001000     0.00     0.00  bubblesort
 18.40      2.93     0.54  1000000     0.00     0.00  find_rank_student
  0.34      2.94     0.01        1     0.01     2.94  sort_students
  0.00      2.94     0.00     1000     0.00     0.00  generate_array
  0.00      2.94     0.00        2     0.00     0.00  free_array
  0.00      2.94     0.00        1     0.00     0.00  generate_grades
  0.00      2.94     0.00        1     0.00     0.00  generate_ranks

index % time    self  children    called     name
                0.01    2.93       1/1           main [2]
[1]    100.0    0.01    2.93       1         sort_students [1]
                0.54    2.39 1000000/1000000     find_rank_student [3]
                0.00    0.00    1000/1001000     bubblesort [4]
-----------------------------------------------
                                                 <spontaneous>
[2]    100.0    0.00    2.94                 main [2]
                0.01    2.93       1/1           sort_students [1]
                0.00    0.00       2/2           free_array [6]
                0.00    0.00       1/1           generate_grades [7]
                0.00    0.00       1/1           generate_ranks [8]
-----------------------------------------------
                0.54    2.39 1000000/1000000     sort_students [1]
[3]     99.6    0.54    2.39 1000000         find_rank_student [3]
                2.39    0.00 1000000/1001000     bubblesort [4]
-----------------------------------------------
                0.00    0.00    1000/1001000     sort_students [1]
                2.39    0.00 1000000/1001000     find_rank_student [3]
[4]     81.3    2.39    0.00 1001000         bubblesort [4]
-----------------------------------------------
                0.00    0.00    1000/1000        generate_grades [7]
[5]      0.0    0.00    0.00    1000         generate_array [5]
-----------------------------------------------
                0.00    0.00       2/2           main [2]
[6]      0.0    0.00    0.00       2         free_array [6]
-----------------------------------------------
                0.00    0.00       1/1           main [2]
[7]      0.0    0.00    0.00       1         generate_grades [7]
                0.00    0.00    1000/1000        generate_array [5]
-----------------------------------------------
                0.00    0.00       1/1           main [2]
[8]      0.0    0.00    0.00       1         generate_ranks [8]
-----------------------------------------------

On modifie d'abord bubblesort pour qu'il fonctionne correctement en remplaçant swapped ++ par swapped = 1.
Ensuite on supprime le bubblesort qui est dans la fonction find_rank_student pour gagner du temps sauf qu'on ne gagne pas assez de temps pour passer en dessous d'une secondes.
Quand on remplace le bubblesort restant par heapsort, c'est beacoup plus rapide sauf que le tri ne ce fait pas bien.