Compare commits
No commits in common. "main" and "main" have entirely different histories.
286
note.txt
286
note.txt
@ -1,286 +0,0 @@
|
||||
Arbre d'appelle du programme :
|
||||
main
|
||||
generate_grades
|
||||
generate_array
|
||||
generate_ranks
|
||||
sort_students
|
||||
find_rank_student
|
||||
bubblesort
|
||||
bubblesort
|
||||
free_array
|
||||
|
||||
On a compilé avec la commande suivante :
|
||||
gcc -g -pg -o student_rank student_rank.c heapsort.c bubblesort.c
|
||||
|
||||
|
||||
On a lancé un scénario avec la commande suivante :
|
||||
./student_rank 5 5 1
|
||||
|
||||
On a ensuite lancé gprof avec la commande suivante :
|
||||
gprof ./student_rank
|
||||
|
||||
Un apperçu du résultat est donné ci-dessous :
|
||||
Flat profile:
|
||||
|
||||
Each sample counts as 0.01 seconds.
|
||||
no time accumulated
|
||||
|
||||
% cumulative self self total
|
||||
time seconds seconds calls Ts/call Ts/call name
|
||||
0.00 0.00 0.00 30 0.00 0.00 bubblesort
|
||||
0.00 0.00 0.00 25 0.00 0.00 find_rank_student
|
||||
0.00 0.00 0.00 10 0.00 0.00 print_array
|
||||
0.00 0.00 0.00 5 0.00 0.00 generate_array
|
||||
0.00 0.00 0.00 2 0.00 0.00 free_array
|
||||
0.00 0.00 0.00 2 0.00 0.00 print_student_array
|
||||
0.00 0.00 0.00 1 0.00 0.00 generate_grades
|
||||
0.00 0.00 0.00 1 0.00 0.00 generate_ranks
|
||||
0.00 0.00 0.00 1 0.00 0.00 sort_students
|
||||
|
||||
On peut voir que la fonction bubblesort a été appelée 30 fois et que la fonction find_rank_student a été appelée 25 fois.
|
||||
|
||||
Apperçu du call graph :
|
||||
Call graph (explanation follows)
|
||||
|
||||
|
||||
granularity: each sample hit covers 2 byte(s) no time propagated
|
||||
|
||||
index % time self children called name
|
||||
0.00 0.00 5/30 sort_students [9]
|
||||
0.00 0.00 25/30 find_rank_student [2]
|
||||
[1] 0.0 0.00 0.00 30 bubblesort [1]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 25/25 sort_students [9]
|
||||
[2] 0.0 0.00 0.00 25 find_rank_student [2]
|
||||
0.00 0.00 25/30 bubblesort [1]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 10/10 print_student_array [6]
|
||||
[3] 0.0 0.00 0.00 10 print_array [3]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 5/5 generate_grades [7]
|
||||
[4] 0.0 0.00 0.00 5 generate_array [4]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 2/2 main [16]
|
||||
[5] 0.0 0.00 0.00 2 free_array [5]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 2/2 main [16]
|
||||
[6] 0.0 0.00 0.00 2 print_student_array [6]
|
||||
0.00 0.00 10/10 print_array [3]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 1/1 main [16]
|
||||
[7] 0.0 0.00 0.00 1 generate_grades [7]
|
||||
0.00 0.00 5/5 generate_array [4]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 1/1 main [16]
|
||||
[8] 0.0 0.00 0.00 1 generate_ranks [8]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 1/1 main [16]
|
||||
[9] 0.0 0.00 0.00 1 sort_students [9]
|
||||
0.00 0.00 25/25 find_rank_student [2]
|
||||
0.00 0.00 5/30 bubblesort [1]
|
||||
-----------------------------------------------
|
||||
|
||||
On peut voir que la fonction bubblesort a été appelée 30 fois, 5 fois par la fonction sort_students et 25 fois par la fonction find_rank_student.
|
||||
La fonction find_rank_student a été appelée 25 fois par sort_students et à chaque fois elle appelle la fonction bubblesort.
|
||||
|
||||
On a relancé le scénario en changeant les paramètres de la commande :
|
||||
./student_rank 1000 1000 0
|
||||
|
||||
On a relancé gprof avec la commande suivante :
|
||||
gprof ./student_rank
|
||||
|
||||
Un apperçu du résultat est donné ci-dessous :
|
||||
Flat profile:
|
||||
|
||||
Each sample counts as 0.01 seconds.
|
||||
% cumulative self self total
|
||||
time seconds seconds calls s/call s/call name
|
||||
83.16 5.11 5.11 1001000 0.00 0.00 bubblesort
|
||||
16.30 6.11 1.00 1000000 0.00 0.00 find_rank_student
|
||||
0.65 6.15 0.04 1 0.04 6.15 sort_students
|
||||
0.00 6.15 0.00 1000 0.00 0.00 generate_array
|
||||
0.00 6.15 0.00 2 0.00 0.00 free_array
|
||||
0.00 6.15 0.00 1 0.00 0.00 generate_grades
|
||||
0.00 6.15 0.00 1 0.00 0.00 generate_ranks
|
||||
|
||||
En comparaison avec le premier scénario, on peut voir que la fonction bubblesort a été appelée 1001000 fois et que la fonction find_rank_student a été appelée 1000000 fois.
|
||||
On peut voir aussi que le programme a passé 6.15 secondes à exécuter, la majorité du temps a été passé dans la fonction bubblesort 5.11 secondes (83.16% du temps).
|
||||
|
||||
Apperçu du call graph :
|
||||
Call graph (explanation follows)
|
||||
|
||||
|
||||
granularity: each sample hit covers 2 byte(s) for 0.16% of 6.15 seconds
|
||||
|
||||
index % time self children called name
|
||||
0.04 6.11 1/1 main [2]
|
||||
[1] 100.0 0.04 6.11 1 sort_students [1]
|
||||
1.00 5.10 1000000/1000000 find_rank_student [3]
|
||||
0.01 0.00 1000/1001000 bubblesort [4]
|
||||
-----------------------------------------------
|
||||
<spontaneous>
|
||||
[2] 100.0 0.00 6.15 main [2]
|
||||
0.04 6.11 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]
|
||||
-----------------------------------------------
|
||||
1.00 5.10 1000000/1000000 sort_students [1]
|
||||
[3] 99.3 1.00 5.10 1000000 find_rank_student [3]
|
||||
5.10 0.00 1000000/1001000 bubblesort [4]
|
||||
-----------------------------------------------
|
||||
0.01 0.00 1000/1001000 sort_students [1]
|
||||
5.10 0.00 1000000/1001000 find_rank_student [3]
|
||||
[4] 83.1 5.11 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 peut voir que la fonction bubblesort a été appelée 1001000 fois, 1000 fois par la fonction generate_array et 1000000 fois par la fonction find_rank_student.
|
||||
|
||||
Par la suite on a essayé de lancer le programme une nouvelle fois avec des paramètres encore plus grands :
|
||||
./student_rank 1000 10000 0
|
||||
|
||||
Ce qu'on obtient avec gprof :
|
||||
Flat profile:
|
||||
|
||||
Each sample counts as 0.01 seconds.
|
||||
% cumulative self self total
|
||||
time seconds seconds calls s/call s/call name
|
||||
83.84 52.32 52.32 10010000 0.00 0.00 bubblesort
|
||||
13.46 60.72 8.40 10000000 0.00 0.00 find_rank_student
|
||||
2.60 62.34 1.62 1 1.62 62.34 sort_students
|
||||
0.11 62.41 0.07 1 0.07 0.07 generate_ranks
|
||||
0.08 62.46 0.05 1000 0.00 0.00 generate_array
|
||||
0.02 62.47 0.01 print_student_array
|
||||
0.00 62.47 0.00 2 0.00 0.00 free_array
|
||||
0.00 62.47 0.00 1 0.00 0.05 generate_grades
|
||||
|
||||
|
||||
Call graph
|
||||
|
||||
|
||||
granularity: each sample hit covers 2 byte(s) for 0.02% of 62.47 seconds
|
||||
|
||||
index % time self children called name
|
||||
<spontaneous>
|
||||
[1] 100.0 0.00 62.46 main [1]
|
||||
1.62 60.72 1/1 sort_students [2]
|
||||
0.07 0.00 1/1 generate_ranks [5]
|
||||
0.00 0.05 1/1 generate_grades [7]
|
||||
0.00 0.00 2/2 free_array [9]
|
||||
-----------------------------------------------
|
||||
1.62 60.72 1/1 main [1]
|
||||
[2] 99.8 1.62 60.72 1 sort_students [2]
|
||||
8.40 52.27 10000000/10000000 find_rank_student [3]
|
||||
0.05 0.00 10000/10010000 bubblesort [4]
|
||||
-----------------------------------------------
|
||||
8.40 52.27 10000000/10000000 sort_students [2]
|
||||
[3] 97.1 8.40 52.27 10000000 find_rank_student [3]
|
||||
52.27 0.00 10000000/10010000 bubblesort [4]
|
||||
-----------------------------------------------
|
||||
0.05 0.00 10000/10010000 sort_students [2]
|
||||
52.27 0.00 10000000/10010000 find_rank_student [3]
|
||||
[4] 83.8 52.32 0.00 10010000 bubblesort [4]
|
||||
-----------------------------------------------
|
||||
0.07 0.00 1/1 main [1]
|
||||
[5] 0.1 0.07 0.00 1 generate_ranks [5]
|
||||
-----------------------------------------------
|
||||
0.05 0.00 1000/1000 generate_grades [7]
|
||||
[6] 0.1 0.05 0.00 1000 generate_array [6]
|
||||
-----------------------------------------------
|
||||
0.00 0.05 1/1 main [1]
|
||||
[7] 0.1 0.00 0.05 1 generate_grades [7]
|
||||
0.05 0.00 1000/1000 generate_array [6]
|
||||
-----------------------------------------------
|
||||
<spontaneous>
|
||||
[8] 0.0 0.01 0.00 print_student_array [8]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 2/2 main [1]
|
||||
[9] 0.0 0.00 0.00 2 free_array [9]
|
||||
-----------------------------------------------
|
||||
|
||||
|
||||
Idées pour améliorer le programme :
|
||||
- Appeler bubblesort moins souvent
|
||||
- Optimiser bubblesort
|
||||
- Appeler sort_students moins souvent car elle appelle bubblesort et find_rank_student qui sont les fonctions qui prennent le plus de temps
|
||||
|
||||
On remarque aussi qu'on appelle bubblesort une fois en trop, car on l'appelle dans sort_students et dans find_rank_student.
|
||||
On pourrait enlever l'appel de bubblesort dans find_rank_student afin qu'il ne soit appelé qu'une seule fois dans sort_students.
|
||||
|
||||
On recompile et on relance le programme avec les paramètres suivants :
|
||||
./student_rank 1000 10000 0
|
||||
|
||||
On relance gprof et on obtient le résultat suivant :
|
||||
Flat profile:
|
||||
|
||||
Each sample counts as 0.01 seconds.
|
||||
% cumulative self self total
|
||||
time seconds seconds calls ms/call ms/call name
|
||||
48.74 0.37 0.37 10000000 0.00 0.00 find_rank_student
|
||||
27.66 0.58 0.21 1 210.24 620.70 sort_students
|
||||
14.49 0.69 0.11 1 110.12 110.12 generate_ranks
|
||||
5.27 0.73 0.04 10000 0.00 0.00 bubblesort
|
||||
2.63 0.75 0.02 1000 0.02 0.02 generate_array
|
||||
1.32 0.76 0.01 print_student_array
|
||||
0.00 0.76 0.00 2 0.00 0.00 free_array
|
||||
0.00 0.76 0.00 1 0.00 20.02 generate_grades
|
||||
|
||||
|
||||
Call graph
|
||||
|
||||
|
||||
granularity: each sample hit covers 2 byte(s) for 1.31% of 0.76 seconds
|
||||
|
||||
index % time self children called name
|
||||
<spontaneous>
|
||||
[1] 98.7 0.00 0.75 main [1]
|
||||
0.21 0.41 1/1 sort_students [2]
|
||||
0.11 0.00 1/1 generate_ranks [4]
|
||||
0.00 0.02 1/1 generate_grades [7]
|
||||
0.00 0.00 2/2 free_array [9]
|
||||
-----------------------------------------------
|
||||
0.21 0.41 1/1 main [1]
|
||||
[2] 81.6 0.21 0.41 1 sort_students [2]
|
||||
0.37 0.00 10000000/10000000 find_rank_student [3]
|
||||
0.04 0.00 10000/10000 bubblesort [5]
|
||||
-----------------------------------------------
|
||||
0.37 0.00 10000000/10000000 sort_students [2]
|
||||
[3] 48.7 0.37 0.00 10000000 find_rank_student [3]
|
||||
-----------------------------------------------
|
||||
0.11 0.00 1/1 main [1]
|
||||
[4] 14.5 0.11 0.00 1 generate_ranks [4]
|
||||
-----------------------------------------------
|
||||
0.04 0.00 10000/10000 sort_students [2]
|
||||
[5] 5.3 0.04 0.00 10000 bubblesort [5]
|
||||
-----------------------------------------------
|
||||
0.02 0.00 1000/1000 generate_grades [7]
|
||||
[6] 2.6 0.02 0.00 1000 generate_array [6]
|
||||
-----------------------------------------------
|
||||
0.00 0.02 1/1 main [1]
|
||||
[7] 2.6 0.00 0.02 1 generate_grades [7]
|
||||
0.02 0.00 1000/1000 generate_array [6]
|
||||
-----------------------------------------------
|
||||
<spontaneous>
|
||||
[8] 1.3 0.01 0.00 print_student_array [8]
|
||||
-----------------------------------------------
|
||||
0.00 0.00 2/2 main [1]
|
||||
[9] 0.0 0.00 0.00 2 free_array [9]
|
||||
-----------------------------------------------
|
||||
|
||||
On peut voir qu'on a réussi à réduire le temps d'exécution de 62.47 secondes à 0.76 secondes.
|
||||
On voit aussi que la fonction bubblesort est seulement appelée par la fonction sort_students et non plus par find_rank_student.
|
||||
|
||||
Maintenant on va essayer d'optimiser la fonction bubblesort mais la fonction est déjà assez optimisée.
|
||||
BIN
student_rank
BIN
student_rank
Binary file not shown.
@ -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);
|
||||
bubblesort(grades_array,students_number);
|
||||
for(i = students_number-1; i >= 0; i--)
|
||||
{
|
||||
if(grades_array[i] == student_grade)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user