menault/TD1_DEV51_Qualite_Algo
1
0
Fork 17
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Td algo

Browse Source
This commit is contained in:
Tom MOGULJAK 2024-09-03 12:18:55 +02:00
parent ca552281c9
commit 2eb0f7f1d7
4 changed files with 287 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
gmon.out Normal file
View File

Binary file not shown.

286
note.txt Normal file
View File

@ -0,0 +1,286 @@
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 Normal file
View File

Binary file not shown.

2
student_rank.c
View File

@ -55,7 +55,7 @@ int find_rank_student(int student_grade, int* grades_array, int students_number)
{ {
int position = -1; int position = -1;
int i = 0; int i = 0;
bubblesort(grades_array,students_number); //bubblesort(grades_array,students_number);
for(i = students_number-1; i >= 0; i--) for(i = students_number-1; i >= 0; i--)
{ {
if(grades_array[i] == student_grade) if(grades_array[i] == student_grade)