moguljak/TD1_DEV51_Qualite_Algo
1
0
Fork 0
forked from menault/TD1_DEV51_Qualite_Algo
Code Pull Requests 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
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 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)