.gitignore

 */*~
 Python/__pycache__/*
-Sujets/*.tex
-Sujets/*.aux
-Sujets/*.bak
-Sujets/*.log
-Sujets/*.ods
+Sujets/*
+
+CPP/src/*
+CPP/include/*
 
 Corrections/*
 

.gitlab-ci.yml

+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
+   
+

C/main.c

@@ -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);

CPP/arraylist.hpp

@@ -48,8 +48,8 @@ public:
     bool memory_reduction = false;
     if(!data.empty()){
       if( do_we_need_to_reduce_capacity() ){
-	memory_reduction = true;
-	reduce_capacity();
+	      memory_reduction = true;
+	      reduce_capacity();
       }
       data.pop_back();
     }

CPP/main.cpp

@@ -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;
 }

Java/Analyzer.java

@@ -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);
     }
 

Java/ArrayList.java

@@ -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);
     }
 
     /**

Java/Main.java

@@ -10,8 +10,8 @@ public class Main {
         Analyzer time_analysis = new Analyzer();
         // Analyse du nombre de copies faites par les opérations.
         Analyzer copy_analysis = new Analyzer();
-	// Analyse de l'espace mémoire inutilisé.
-	Analyzer memory_analysis = new Analyzer();
+	    // Analyse de l'espace mémoire inutilisé.
+	    Analyzer memory_analysis = new Analyzer();
         long before, after;
         // Booléen permettant de savoir si une allocation a été effectuée.
         boolean memory_allocation;
@@ -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");
     }
 }

Python/analyzer.py

+# -- coding: utf-8 --
 import math
 
 #  Classe utilisee pour faire des statistiques elementaires

Python/arraylist.py

-# Cette classe est un simple proxy vers le type "list" de python
-# Le langage ne permettant pas de manipuler l'espace memoire d'une "list",
-# on se contente ici d'observer son comportement.
-class ArrayListProxy:
-    # Constructeur de la classe ArraylistProxy
-    def __init__(self):
-        self.data = []
-
-    # Ajoute l'element x au tableau
-    #   Complexite en temps/espace, pire cas : O(data.size)
-    #   Complexite en temps/espace, meilleur cas : O(1)
-    #   Complexite amortie : O(1)
-    def append(self, x):
-        self.data.append(x)
-
-    # Supprime le dernier element du tableau
-    def pop_back(self):
-        self.data.pop()
-
-    # Renvoie l'element situe a la position 'pos' dans le tableau
-    def get(self, pos):
-        return self.data[pos]
-
-    # Renvoie le nombre d'elements dans le tableau
-    def get_size(self):
-        return len(data)
-
-        

Python/main.py

+# -- coding: utf-8 --
 import time
 import sys
 
-from arraylist import ArrayListProxy
 from analyzer import Analyzer
 
 # Tableau dynamique.
 a = []
 # Analyse du temps pris par les operations.
 time_analysis = Analyzer();
+# Analyse de la mémoire gaspillée à un instant t.
+memory_analysis = Analyzer();
+# 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__ = 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()
+
     # Enregistrement du temps pris par l'operation
     time_analysis.append((after - before)*10**9)
+    # 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 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+1)
+    memory_analysis.append(wasted_memory)
 
 # Affichage de quelques statistiques sur l'experience.
 sys.stderr.write("Total cost : " + str(time_analysis.get_total_cost())+"\n")
@@ -23,4 +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")
+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")

README.md

-# 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

launch_analysis.sh

+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
+
+

plots/plot_result

 # Script GNUPLOT
 # Dire que le fichier de sortie est un fichier Postscript
-set terminal postscript color
+set terminal pdf color
 
 set xlabel "Nombre d'elements ajoutes" font "Helvetica,24"
 
@@ -12,28 +12,28 @@ set xlabel "Nombre d'elements ajoutes" font "Helvetica,24"
 set ylabel "Temps amorti" font "Helvetica,24"
 
 # Nom du fichier Postscript en sortie
-set output 'eps/dynamic_array_amortized_time_alpha_2.eps' 
+set output 'dynamic_array_amortized_time_alpha_2.pdf' 
 
-plot [0:1000000][0:1000] '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é ###########
 ###############################################################
 # Titre de l'axe des ordonnées
-set ylabel "Mémoire gaspillée" font "Helvetica,24"
+set ylabel "Memoire gaspillee" font "Helvetica,24"
 
 # Nom du fichier Postscript en sortie
-set output 'eps/dynamic_array_wasted_memory_alpha_2.eps' 
+set output 'dynamic_array_wasted_memory_alpha_2.pdf' 
 
-plot 'dynamic_array_memory_c.plot' using 1:2 w lines title "Espace memoire inutilise"
+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 ###########
 #################################################################
 # Titre de l'axe des ordonnées
-set ylabel "Nombre de copie effectuée" font "Helvetica,24"
+set ylabel "Nombre de copies effectuees" font "Helvetica,24"
 
 # Nom du fichier Postscript en sortie
-set output 'eps/dynamic_copy_alpha_2.eps' 
+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"
\ 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