Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • david/sda
  • naima/sda
  • tomeh/sda
3 results
Show changes
Commits on Source (28)
*/*~
Python/__pycache__/*
Sujets/*.tex
Sujets/*.aux
Sujets/*.bak
Sujets/*.log
Sujets/*.ods
Sujets/*
CPP/src/*
CPP/include/*
Corrections/*
......
image: alpine
stages:
- test
sda:test:
script:
- echo "Exercice 1"
- ls -lF AUTHORS.md
- echo "Exercice 2"
- ls -lF plots/*_alpha_2.pdf
- echo "Exercice 3"
- ls -lF plots/my_plot_result
- grep my_plot_result launch_analysis.sh
- ALPHA=$(head -n 1 AUTHORS.md)
- echo "ALPHA ${ALPHA}"
- ls -lF plots/*_alpha_${ALPHA}.pdf
- echo "Exercice 4"
- ls -lF RAPPORT.md
......@@ -44,9 +44,9 @@ int main(int argc, char ** argv){
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../plots/dynamic_array_time_c.plot");
save_values(copy_analysis, "../plots/dynamic_array_copy_c.plot");
save_values(memory_analysis, "../plots/dynamic_array_memory_c.plot");
save_values(time_analysis, "../plots/dynamic_array_time_c_alpha_2.plot");
save_values(copy_analysis, "../plots/dynamic_array_copy_c_alpha_2.plot");
save_values(memory_analysis, "../plots/dynamic_array_memory_c_alpha_2.plot");
// Nettoyage de la mémoire avant la sortie du programme
arraylist_destroy(a);
......
......@@ -45,9 +45,9 @@ int main(int argc, char ** argv){
std::cerr<<"Standard deviation :"<<time_analysis.get_standard_deviation()<<std::endl;
// Sauvegarde les données de l'expérience.
time_analysis.save_values("../plots/dynamic_array_time_cpp.plot");
copy_analysis.save_values("../plots/dynamic_array_copy_cpp.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_cpp.plot");
time_analysis.save_values("../plots/dynamic_array_time_cpp_alpha_2.plot");
copy_analysis.save_values("../plots/dynamic_array_copy_cpp_alpha_2.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_cpp_alpha_2.plot");
return 0;
}
......
......@@ -30,7 +30,7 @@ public class Analyzer {
BigDecimal x_big = new BigDecimal(x);
cost.add(x);
cumulative_cost.add( (!cumulative_cost.isEmpty()) ? cumulative_cost.get(cumulative_cost.size()-1).add(x_big) : x_big);
BigDecimal x_square = x_big.multiply(x_big);
BigDecimal x_square = x_big.multiply(x_big);
cumulative_square = cumulative_square.add(x_square);
}
......
......@@ -90,8 +90,8 @@ public class ArrayList<T> {
Cette fonction augmente la capacité du tableau.
*/
private void enlarge_capacity(){
data = java.util.Arrays.copyOf(data, capacity*2);
capacity *= 2;
data = java.util.Arrays.copyOf(data, capacity);
}
/**
......
......@@ -28,8 +28,8 @@ public class Main {
// Enregistrement du nombre de copies efféctuées par l'opération.
// S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
copy_analysis.append( (memory_allocation == true)? i: 1);
// Enregistrement de l'espace mémoire non-utilisé.
memory_analysis.append( a.capacity() - a.size() );
// Enregistrement de l'espace mémoire non-utilisé.
memory_analysis.append( a.capacity() - a.size() );
}
// Affichage de quelques statistiques sur l'expérience.
......@@ -39,8 +39,8 @@ public class Main {
System.err.println("Standard deviation :"+time_analysis.get_standard_deviation());
// Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
time_analysis.save_values("../plots/dynamic_array_time_java.plot");
copy_analysis.save_values("../plots/dynamic_array_copy_java.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_java.plot");
time_analysis.save_values("../plots/dynamic_array_time_java_alpha_2.plot");
copy_analysis.save_values("../plots/dynamic_array_copy_java_alpha_2.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_java_alpha_2.plot");
}
}
# -- coding: utf-8 --
import math
# Classe utilisee pour faire des statistiques elementaires
......
# -- coding: utf-8 --
import time
import sys
......@@ -9,18 +10,19 @@ a = []
time_analysis = Analyzer();
# Analyse de la mémoire gaspillée à un instant t.
memory_analysis = Analyzer();
# Analyse de la mémoire gaspillée à un instant t.
# Analyse du nombre de copies effectuées à un instant t.
copy_analysis = Analyzer();
# Taille supposée de l'en-tête d'une list en Python
__list_header_size__ = 64
__list_header_size__ = 56
# Taille supposée d'une entrée dans une list en Python
__list_entry_size__ = 8
wasted_memory = sys.getsizeof(a)-__list_header_size__
for i in range(1000000):
previous_size = sys.getsizeof(a)
before = time.time()
a.append(i)
after = time.time()
......@@ -30,12 +32,12 @@ for i in range(1000000):
# Enregistrement du nombre de copie effectuées par l'opération
# S'il n'y avait pas d'espace gaspillé à l'étape précédente,
# alors une réallocation a eu lieu à cette étape.
if wasted_memory == 0:
if sys.getsizeof(a) > previous_size:
copy_analysis.append(i+1)
else:
copy_analysis.append(1)
# Enregistrement de l'espace mémoire gaspillé à un instant donné
wasted_memory = sys.getsizeof(a)-__list_header_size__ - __list_entry_size__*i
wasted_memory = sys.getsizeof(a)-__list_header_size__ - __list_entry_size__*(i+1)
memory_analysis.append(wasted_memory)
# Affichage de quelques statistiques sur l'experience.
......@@ -45,6 +47,6 @@ sys.stderr.write("Variance :" + str(time_analysis.get_variance())+"\n")
sys.stderr.write("Standard deviation :" + str(time_analysis.get_standard_deviation())+"\n")
# Sauvegarde les donnees de l'experience.
time_analysis.save_values("../plots/dynamic_array_time_python.plot")
memory_analysis.save_values("../plots/dynamic_array_memory_python.plot")
copy_analysis.save_values("../plots/dynamic_array_copy_python.plot")
time_analysis.save_values("../plots/dynamic_array_time_python_alpha_2.plot")
memory_analysis.save_values("../plots/dynamic_array_memory_python_alpha_2.plot")
copy_analysis.save_values("../plots/dynamic_array_copy_python_alpha_2.plot")
# Compilation et exécution en C:
# Sujet de TP 1: Gitlab, Benchmarks et tableaux dynamiques
cd C/
## Règles pour ce semestre
make
Vous travaillerez en binôme durant les TPs. Il ne sera pas possible de changer
de binôme en cours de semestre.
./arraylist_analysis
Il est interdit de partager du code avec d'autres binômes ou de "s'en inspirer".
make clean
Toute ressemblance suspecte sera AUTOMATIQUEMENT considérée comme de la fraude
et sévèrement sanctionnée.
cd ..
Chaque semaine, un rendu vous sera demandé (vous aurez jusqu'au dimanche soir pour
rendre le TP si vous ne finissez pas à temps) via gitlab.
# Compilation et exécution en C++:
Vos travaux seront évalués une fois à mi-semestre et une fois à la fin du semestre.
cd CPP/
## Exercice 1: git
### Clonez le projet sda sur votre compte étudiant
make
Dans votre terminal, commencez par la configuration de votre utilisateur git:
git config --global user.name "NOM_PRENOM"
(le reste du TP peut se faire à partir de n'importe quelle session)
./arraylist_analysis
Placez vous dans le répertoire où vous souhaitez créer le dossier
make clean
`git clone https://depot.lipn.univ-paris13.fr/david/sda.git`
cd ..
`cd sda`
# Compilation et exécution en Java:
### Vérifiez que vous êtes dans la branche tp1
cd Java
`git branch`
javac *
Si n'êtes pas dans la branche tp1, tapez
java Main
`git checkout tp1`
cd ..
### Créez votre propre branche
# Exécution en Python
Le nom de votre branche est constitué de vos numéros d'étudiants séparés par un `_`
cd Python
`git checkout -b tp1_NUMERO1_NUMERO2`
python main.py
### Ajoutez un fichier `AUTHORS.md` à votre branche
cd ..
A la racine du projet, créez un fichier `AUTHORS.md` contenant 2 lignes avec vos noms, prénoms et numéros d'étudiants.
# Observation des résultats
### Dans le répertoire plots, lisez le contenu du fichier plot_result
Ajoutez ensuite ce fichier au projet
cd plots
more plot_result
`git add AUTHORS.md`
### puis lancez ce script avec gnuplot
`git commit -am "Ajout du fichier AUTHORS.md"`
gnuplot plot_result
### Poussez votre branche sur gitlab
`git push -u origin tp1_NUMERO1_NUMERO2`
### Regardez à présent les courbes obtenus dans le répertoire eps/
Login : `tp_sda`
Mot de passe : `structure`
gv eps/dynamic_array_amortized_time_alpha_2.eps
### Vérifiez sur gitlab
Sur la page de gitlab:
- vérifiez que la branche a été poussée dans `Repository -> Branches`
- vérifiez que le pipeline a échoué (car vous n'avez pas encore fini le TP), dans `CI/CD -> Pipelines`
- cliquez sur `failed` pour voir le détail des tests effectués
## Exercice 2: Lancer les benchmarks
Vérifiez que le répertoire `plots` ne contient que le fichier `plot_result`.
Nous allons à présent tester différentes implémentations des tableaux dynamiques dans différents langages.
Lisez les fichiers `main` de chaque langage et vérifiez que la même expérience est bien effectuée à chaque fois.
Exécutez le script `SHELL` (le lire ne vous fera pas de mal non plus):
`sh launch_analysis.sh`
Une fois les calculs effectués, regardez les fichiers `pdf` obtenus dans le répertoire `plots`
Ajoutez tous les fichiers pdf obtenus à votre branche en utilisant les commandes
`git add plots/*.pdf`
`git commit -am "Première expérience"`
`git push`
## Exercice 3: A vous de jouer!
Dans le langage de votre choix (C, C++, JAVA, pas possible en Python), modifiez la fonction `enlarge_capacity`
afin de multiplier la capacité du tableaux par une autre constante `alpha` que 2 (Demandez à votre chargé de TP
de choisir une constante alpha pour votre binôme).
Ajouter une ligne au début du fichier AUTHORS.md contenant la valeur de alpha (et uniquement cette valeur).
Dans la fonction `main`, changez le nom de fichiers de sortie en ramplaçant `alpha_2` par `alpha_votre_valeur`
Dans le répertoire `plots`, faites une copie du fichier `plot_result`
`cp plot_result my_plot_result`
Modifiez le fichier `my_plot_result` pour ne fournir que des courbes dans le langage que vous avez choisi.
Modifiez également le nom des fichiers pdf en sortie afin qu'ils contiennent la bonne valeur de alpha.
Modifiez le fichier `launch_analysis.sh` afin qu'il exécute gnuplot à partir de `my_plot_result`
Relancez le script `launch_analysis.sh`
Ajoutez les résultats (fichiers pdf) à votre branche.
## Exercice 4: Au rapport!
Créez un fichier RAPPORT.md à la racine projet.
1) Tentez d'expliquer pourquoi certains langages sont plus rapides que d'autres dans cette expérience.
2) Observez l'espace mémoire inutilisé au fur et à mesure du programme. Qu'en pensez vous?
Imaginez un scénario dans lequel cela pourrait poser problème.
3) Décrivez les différences obtenues en faisant varier alpha dans les deux expériences.
A FINIR AVANT DIMANCHE !
Votre travail n'est validé que si le pipeline réussi.
\ No newline at end of file
File deleted
RED='\033[0;31m'
NC='\033[0m' # No Color
# Compilation et exécution en C:
echo "${RED} Compilation du code source en C ${NC}"
cd C/
make
echo "${RED} Exécution des benchmarks en C ${NC}"
./arraylist_analysis
echo "${RED} Nettoyage ${NC}"
make clean
cd ..
# Compilation et exécution en C++:
echo "${RED} Compilation du code source en C++ ${NC}"
cd CPP/
make
echo "${RED} Exécution des benchmarks en C++ ${NC}"
./arraylist_analysis
echo "${RED} Nettoyage ${NC}"
make clean
cd ..
# Compilation et exécution en Java:
echo "${RED} Compilation du code source en Java ${NC}"
cd Java
javac *
echo "${RED} Exécution des benchmarks en Java ${NC}"
java Main
echo "${RED} Nettoyage ${NC}"
rm *.class
cd ..
# Exécution en Python
echo "${RED} Compilation du code source en Python ${NC}"
cd Python
echo "${RED} Exécution des benchmarks en Python ${NC}"
python main.py
cd ..
# Observation des résultats
### Dans le répertoire plots, lisez le contenu du fichier plot_result
cd plots
more plot_result
### puis lancez ce script avec gnuplot
gnuplot plot_result
......@@ -12,9 +12,9 @@ set xlabel "Nombre d'elements ajoutes" font "Helvetica,24"
set ylabel "Temps amorti" font "Helvetica,24"
# Nom du fichier Postscript en sortie
set output 'pdf/dynamic_array_amortized_time_alpha_2.pdf'
set output 'dynamic_array_amortized_time_alpha_2.pdf'
plot [0:1000000][0:600] 'dynamic_array_time_c.plot' using 1:3 w lines title "Amortized C", 'dynamic_array_time_cpp.plot' using 1:3 w lines title "Amortized C++", 'dynamic_array_time_java.plot' using 1:3 w lines title "Amortized JAVA", 'dynamic_array_time_python.plot' using 1:3 w lines title "Amortized Python"
plot [0:1000000][0:600] 'dynamic_array_time_c_alpha_2.plot' using 1:3 w lines title "Amortized C", 'dynamic_array_time_cpp_alpha_2.plot' using 1:3 w lines title "Amortized C++", 'dynamic_array_time_java_alpha_2.plot' using 1:3 w lines title "Amortized JAVA", 'dynamic_array_time_python_alpha_2.plot' using 1:3 w lines title "Amortized Python"
###############################################################
########### Affichage de l'espace mémoire gaspillé ###########
......@@ -23,9 +23,9 @@ plot [0:1000000][0:600] 'dynamic_array_time_c.plot' using 1:3 w lines title "Amo
set ylabel "Memoire gaspillee" font "Helvetica,24"
# Nom du fichier Postscript en sortie
set output 'pdf/dynamic_array_wasted_memory_alpha_2.pdf'
set output 'dynamic_array_wasted_memory_alpha_2.pdf'
plot 'dynamic_array_memory_c.plot' using 1:2 w lines title "Espace memoire inutilise C", 'dynamic_array_memory_python.plot' using 1:2 w lines title "Espace memoire inutilise Python"
plot 'dynamic_array_memory_c_alpha_2.plot' using 1:2 w lines title "Espace memoire inutilise C", 'dynamic_array_memory_python_alpha_2.plot' using 1:2 w lines title "Espace memoire inutilise Python"
#################################################################
########### Affichage du nombre de copies effectuées ###########
......@@ -34,6 +34,6 @@ plot 'dynamic_array_memory_c.plot' using 1:2 w lines title "Espace memoire inuti
set ylabel "Nombre de copies effectuees" font "Helvetica,24"
# Nom du fichier Postscript en sortie
set output 'pdf/dynamic_array_copy_alpha_2.pdf'
set output 'dynamic_array_copy_alpha_2.pdf'
plot 'dynamic_array_copy_c.plot' using 1:2 w boxes title "Nombre de copies de valeurs effectuees C", 'dynamic_array_copy_python.plot' using 1:2 w boxes title "Nombre de copies de valeurs effectuees Python"
\ No newline at end of file
plot 'dynamic_array_copy_c_alpha_2.plot' using 1:2 w boxes title "Nombre de copies de valeurs effectuees C", 'dynamic_array_copy_python_alpha_2.plot' using 1:2 w boxes title "Nombre de copies de valeurs effectuees Python"
\ No newline at end of file