DAVID AKAGUNDUZ ET JAMES BOUTARIC TD1 Nous avons commencé par lancer les progmramme récuprér depuis le git de Maxime Menault puis nous les avons compiler et lancer avec des valeur qui prenne un peu de temps nous avons decider de prendre comem valeur 1000 et 1000 pour que ca dure un minimun de temps d'éxécution ex : gcc -g -pg -o student_rank student_rank.c heapsort.c bubblesort.c ./student_rank 5000 1000 0 Suite a cela nous utilisons gprof pour analyser le programme lancer , gprof ./student_rank il y a plussieur information qu'on peut retrouver comme : le temps de répartition entre les differentes fonctions, le temps d'd'éxecution cumulé au fur et à mesure (dans l'ordre d'utilisation des fonction) , le temps pris par chacune des fonctions, le nombre de fois que la fonction a était appeller, le nombre de temps pris par appel en milliseconde, le nombre total pris pour avoir éxécuter tout les appel de la fonction et aussi celle que lui appel (ses enfants). enfin le nom de la fonction en question. ex: Flat Profile Each sample counts as 0.01 seconds. % cumulative self self total time seconds seconds calls s/call s/call name 79.80 2.35 2.35 1001000 0.00 0.00 bubblesort 19.35 2.92 0.57 1000000 0.00 0.00 find_rank_student 0.34 2.93 0.01 1000 0.00 0.00 generate_array 0.34 2.94 0.01 1 0.01 0.01 generate_ranks 0.34 2.96 0.01 1 0.01 2.93 sort_students 0.00 2.96 0.00 2 0.00 0.00 free_array 0.00 2.96 0.00 1 0.00 0.01 generate_grades ---------------------------------------------------------------------------------------------- Call graph (explanation follows) granularity: each sample hit covers 2 byte(s) for 0.34% of 2.96 seconds index % time self children called name [1] 100.0 0.00 2.96 main [1] 0.01 2.92 1/1 sort_students [2] 0.00 0.01 1/1 generate_grades [6] 0.01 0.00 1/1 generate_ranks [7] 0.00 0.00 2/2 free_array [8] ----------------------------------------------- 0.01 2.92 1/1 main [1] [2] 99.3 0.01 2.92 1 sort_students [2] 0.57 2.35 1000000/1000000 find_rank_student [3] 0.00 0.00 1000/1001000 bubblesort [4] ----------------------------------------------- 0.57 2.35 1000000/1000000 sort_students [2] [3] 98.9 0.57 2.35 1000000 find_rank_student [3] 2.35 0.00 1000000/1001000 bubblesort [4] ----------------------------------------------- 0.00 0.00 1000/1001000 sort_students [2] 2.35 0.00 1000000/1001000 find_rank_student [3] [4] 79.7 2.35 0.00 1001000 bubblesort [4] ----------------------------------------------- 0.01 0.00 1000/1000 generate_grades [6] [5] 0.3 0.01 0.00 1000 generate_array [5] ----------------------------------------------- 0.00 0.01 1/1 main [1] [6] 0.3 0.00 0.01 1 generate_grades [6] 0.01 0.00 1000/1000 generate_array [5] ----------------------------------------------- 0.01 0.00 1/1 main [1] [7] 0.3 0.01 0.00 1 generate_ranks [7] ----------------------------------------------- 0.00 0.00 2/2 main [1] [8] 0.0 0.00 0.00 2 free_array [8] ----------------------------------------------- les information comme : l'index (pour chaque element de la table) le pourcentage detemsp pris par chacune des des fonction et de ses enfants Self le nomre total de temps pris par la fonction Children le nombre total pris par ses enfant Le nombre de fois que la fonction est appeler ainsi quele nom de la fonction en question Résumer : Le grpof : ----> Flat profile : temps et nbr d'éxecution/fonctions (ici bublesort 80%) ----> Call Graph : Vor arbre fonction + temps et nombre d'éxecution/fonction Fonction la plus lente: bubblesort Nombre appel important de bubblesort dans le find_rank_student Nous avons analyser le code et nosu avons trouvé comment optimiser en reduisant le temps d'éxecution dans le code ( i lfaut supprimer l'apple dela fonction bubblesort dans find_rank_student) Pour corriger l'erreur du calssement des note des élève il faut modiifer la condition du tri a bulle ( bubblesort) car sa condition n'était correct du fait qu'elle valide en permanance sa condition.( mauvaise condition i ldoit verifier qu'il y a aucun échange entre pour que ca soit bon) void bubblesort(int* array, int length) { int swapped, i, tmp; do { swapped = 0; for(i=1;i array[i]) { tmp = array[i-1]; array[i-1] = array[i]; array[i] = tmp; swapped++; } } } while(swapped>0); } ---------------------------------------------- Si on change bubblesort par heapsort alors le temps d'exécution est beaucoup plus rapide Flat profile: Each sample counts as 0.01 seconds. % cumulative self self total time seconds seconds calls ms/call ms/call name 100.17 0.04 0.04 1000000 0.00 0.00 find_rank_student 0.00 0.04 0.00 1500000 0.00 0.00 sift 0.00 0.04 0.00 1000 0.00 0.00 generate_array 0.00 0.04 0.00 1000 0.00 0.00 heapsort 0.00 0.04 0.00 2 0.00 0.00 free_array 0.00 0.04 0.00 1 0.00 0.00 generate_grades 0.00 0.04 0.00 1 0.00 0.00 generate_ranks 0.00 0.04 0.00 1 0.00 40.07 sort_students -------------------------------------------------- Call graph granularity: each sample hit covers 2 byte(s) for 24.96% of 0.04 seconds index % time self children called name 0.04 0.00 1000000/1000000 sort_students [2] [1] 100.0 0.04 0.00 1000000 find_rank_student [1] ----------------------------------------------- 0.00 0.04 1/1 main [3] [2] 100.0 0.00 0.04 1 sort_students [2] 0.04 0.00 1000000/1000000 find_rank_student [1] 0.00 0.00 1000/1000 heapsort [6] ----------------------------------------------- [3] 100.0 0.00 0.04 main [3] 0.00 0.04 1/1 sort_students [2] 0.00 0.00 2/2 free_array [7] 0.00 0.00 1/1 generate_grades [8] 0.00 0.00 1/1 generate_ranks [9] ----------------------------------------------- 384971 sift [4] 0.00 0.00 1500000/1500000 heapsort [6] [4] 0.0 0.00 0.00 1500000+384971 sift [4] 384971 sift [4] ----------------------------------------------- 0.00 0.00 1000/1000 generate_grades [8] [5] 0.0 0.00 0.00 1000 generate_array [5] ----------------------------------------------- 0.00 0.00 1000/1000 sort_students [2] [6] 0.0 0.00 0.00 1000 heapsort [6] 0.00 0.00 1500000/1500000 sift [4] ----------------------------------------------- 0.00 0.00 2/2 main [3] [7] 0.0 0.00 0.00 2 free_array [7] ----------------------------------------------- 0.00 0.00 1/1 main [3] [8] 0.0 0.00 0.00 1 generate_grades [8] 0.00 0.00 1000/1000 generate_array [5] ----------------------------------------------- 0.00 0.00 1/1 main [3] [9] 0.0 0.00 0.00 1 generate_ranks [9] -----------------------------------------------