[raban@salle235-04 TD1_DEV51_Qualite_Algo]$ time ./student_rank 1000 1000 0

real	0m2.975s
user	0m2.963s
sys	    0m0.007s

[raban@salle235-04 TD1_DEV51_Qualite_Algo]$ gprof ./student_rank

Flat Profile : temps et nombre d'exécution par fonction

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls   s/call   s/call  name    
 79.14      2.32     2.32  1001000     0.00     0.00  bubblesort
 18.46      2.86     0.54  1000000     0.00     0.00  find_rank_student
  2.05      2.92     0.06        1     0.06     2.92  sort_students
  0.34      2.93     0.01        1     0.01     0.01  generate_ranks
  0.17      2.93     0.01     1000     0.00     0.00  generate_array
  0.00      2.93     0.00        2     0.00     0.00  free_array
  0.00      2.93     0.00        1     0.00     0.01  generate_grades

légende : 

% time : pourcentage de temps passé sur une fonction.

Cumulative seconds : somme des secondes compté par celle de la fonction et ceux listés au dela de la seconde

Self seconds : le nombre de seconde compté par cette fonction seul

Calls : nombre de fois où la fonction est appelé

Self ms/call : le nombre moyen de millisecondes passé dans la fonction par appel (si la fonction est profilé 
), sinon la colonne reste vide

Total ms/call : le nombre moyen de millisecondes passé sur la fonction et ses descendants par appel (si la fonction est profilé 
), sinon la colonne reste vide

Name : nom de la fonction

Call graph : arbre d'appel fonctions + temps execution par fonction

index % time    self  children    called     name
                                                 <spontaneous>
[1]    100.0    0.00    2.93                 main [1]
                0.06    2.86       1/1           sort_students [2]
                0.01    0.00       1/1           generate_ranks [5]
                0.00    0.01       1/1           generate_grades [7]
                0.00    0.00       2/2           free_array [8]
-----------------------------------------------
                0.06    2.86       1/1           main [1]
[2]     99.5    0.06    2.86       1         sort_students [2]
                0.54    2.32 1000000/1000000     find_rank_student [3]
                0.00    0.00    1000/1001000     bubblesort [4]
-----------------------------------------------
                0.54    2.32 1000000/1000000     sort_students [2]
[3]     97.4    0.54    2.32 1000000         find_rank_student [3]
                2.32    0.00 1000000/1001000     bubblesort [4]
-----------------------------------------------
                0.00    0.00    1000/1001000     sort_students [2]
                2.32    0.00 1000000/1001000     find_rank_student [3]
[4]     79.0    2.32    0.00 1001000         bubblesort [4]
-----------------------------------------------
                0.01    0.00       1/1           main [1]
[5]      0.3    0.01    0.00       1         generate_ranks [5]
-----------------------------------------------
                0.01    0.00    1000/1000        generate_grades [7]
[6]      0.2    0.01    0.00    1000         generate_array [6]
-----------------------------------------------
                0.00    0.01       1/1           main [1]
[7]      0.2    0.00    0.01       1         generate_grades [7]
                0.01    0.00    1000/1000        generate_array [6]
-----------------------------------------------
                0.00    0.00       2/2           main [1]
[8]      0.0    0.00    0.00       2         free_array [8]
-----------------------------------------------

légende : 

Index : nombre unique donné à chaque éléments de la table

% time : pourcentage du "total" de temps qui ont été passé sur cette fonction et ses enfants

Self : nombre total de temps passé par la fonction

Children : nombre total de temps passé par la fonction par ses enfants

Called : nombre de fois que la fonction à été appellé. Si la fonction s'appelle elle-même, le nombre n'inclue pas les appelles récursifs

Name : nom de la fonction


fonction la plus lente : bubblesort

N?ombre d'appel important de bubblesortr  dans la fonction : 1000000


Optimisation possible : 
- modifier find_rank_student et sort_student afin qu'il y est un seul tri + une gestion des égalité un peu mieux
- dans bubblesort, mettre while(swapped>0)

temps : 3,145s, c'est bien mais pas assez

usage de heapsort au lieu de bubblesort.

temps : 0.124s super efficace!

Pour qiktri, il est plus lent alors qu'il est censé etre plus rapide.