From e9382975732d4890f966fb10ac4e4ad947a5a6c0 Mon Sep 17 00:00:00 2001
From: david <david@lipn.fr>
Date: Mon, 9 Sep 2019 14:36:51 +0200
Subject: [PATCH] =?UTF-8?q?Ajout=20d'une=20analyse=20de=20l'espace=20m?=
=?UTF-8?q?=C3=A9moire=20inutilis=C3=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
TP1/C/arraylist.c | 6 +++++-
TP1/C/arraylist.h | 10 +++++++++-
TP1/C/main.c | 10 ++++++++--
TP1/CPP/arraylist.hpp | 9 ++++++++-
TP1/CPP/main.cpp | 7 ++++++-
TP1/Java/ArrayListProxy.java | 11 ++++++++++-
TP1/Java/Main.java | 6 +++++-
7 files changed, 51 insertions(+), 8 deletions(-)
diff --git a/TP1/C/arraylist.c b/TP1/C/arraylist.c
index f77a800..32d45a6 100644
--- a/TP1/C/arraylist.c
+++ b/TP1/C/arraylist.c
@@ -51,10 +51,14 @@ int arraylist_get(arraylist_t * a, int pos){
return -1;
}
-size_t arraylist_get_size(arraylist_t * a){
+size_t arraylist_size(arraylist_t * a){
return ( a!=NULL) ? a->size : -1;
}
+size_t arraylist_capacity(arraylist_t * a){
+ return ( a!=NULL) ? a->capacity : -1;
+}
+
char arraylist_do_we_need_to_enlarge_capacity(arraylist_t * a){
return ( a->size >= (a->capacity * 3)/4 )? TRUE: FALSE;
}
diff --git a/TP1/C/arraylist.h b/TP1/C/arraylist.h
index 26dd805..0f4a12b 100644
--- a/TP1/C/arraylist.h
+++ b/TP1/C/arraylist.h
@@ -70,7 +70,15 @@ int arraylist_get(arraylist_t * a, int pos);
@param a est un pointeur vers un tableau.
@returns le nombre d'éléments stockés dans le tableau.
*/
-size_t arraylist_get_size(arraylist_t * a);
+size_t arraylist_size(arraylist_t * a);
+
+/**
+ Renvoie la capacité de stockage du tableau.
+ Complexité en temps/espace, pire cas : O(1)
+ @param a est un pointeur vers un tableau.
+ @returns la capacité de stockage du tableau.
+ */
+size_t arraylist_capacity(arraylist_t * a);
/**
Cette fonction détermine la règle selon laquelle un espace mémoire plus grand sera alloué ou non.
diff --git a/TP1/C/main.c b/TP1/C/main.c
index 35eeefb..43523a4 100644
--- a/TP1/C/main.c
+++ b/TP1/C/main.c
@@ -12,7 +12,9 @@ int main(int argc, char ** argv){
// Analyse du temps pris par les opérations.
analyzer_t * time_analysis = analyzer_create();
// Analyse du nombre de copies faites par les opérations.
- analyzer_t * copy_analysis = analyzer_create();
+ analyzer_t * copy_analysis = analyzer_create();
+ // Analyse de l'espace mémoire inutilisé.
+ analyzer_t * memory_analysis = analyzer_create();
struct timespec before, after;
// utilisé comme booléen pour savoir si une allocation a été effectuée.
char memory_allocation;
@@ -28,6 +30,8 @@ int main(int argc, char ** argv){
// 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.
analyzer_append(copy_analysis, (memory_allocation)? i:1 );
+ // Enregistrement de l'espace mémoire non-utilisé.
+ analyzer_append(memory_analysis,arraylist_capacity(a)-arraylist_size(a));
}
// Affichage de quelques statistiques sur l'expérience.
@@ -36,13 +40,15 @@ int main(int argc, char ** argv){
fprintf(stderr, "Variance: %lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %lf\n", get_standard_deviation(time_analysis));
- // Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
+ // Sauvegarde les données de l'expérience.
save_values(time_analysis, "../dynamic_array_time_c.plot");
save_values(copy_analysis, "../dynamic_array_copy_c.plot");
+ save_values(memory_analysis, "../dynamic_array_memory_c.plot");
// Nettoyage de la mémoire avant la sortie du programme
arraylist_destroy(a);
analyzer_destroy(time_analysis);
analyzer_destroy(copy_analysis);
+ analyzer_destroy(memory_analysis);
return EXIT_SUCCESS;
}
diff --git a/TP1/CPP/arraylist.hpp b/TP1/CPP/arraylist.hpp
index 9f4d5d6..fdc667c 100644
--- a/TP1/CPP/arraylist.hpp
+++ b/TP1/CPP/arraylist.hpp
@@ -71,8 +71,15 @@ public:
Complexité en temps/espace, pire cas : O(1)
@returns le nombre d'éléments stockés dans le tableau.
*/
- const size_t get_size(){ return data.size(); }
+ const size_t size(){ return data.size(); }
+ /**
+ Renvoie la capacité de stockage du tableau.
+ Complexité en temps/espace, pire cas : O(1)
+ @returns le nombre d'éléments stockés dans le tableau.
+ */
+ const size_t capacity(){ return data.capacity(); }
+
private:
// Vecteur contenant les données.
std::vector<P> data;
diff --git a/TP1/CPP/main.cpp b/TP1/CPP/main.cpp
index 4907713..ede756d 100644
--- a/TP1/CPP/main.cpp
+++ b/TP1/CPP/main.cpp
@@ -13,6 +13,8 @@ int main(int argc, char ** argv){
Analyzer time_analysis;
// Analyse du nombre de copies faites par les opérations.
Analyzer copy_analysis;
+ // Analyse de l'espace mémoire inutilisé.
+ Analyzer memory_analysis;
struct timespec before, after;
// Booléen permettant de savoir si une allocation a été effectuée.
bool memory_allocation;
@@ -28,6 +30,8 @@ int main(int argc, char ** argv){
// 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)? i:1 );
+ // Enregistrement de l'espace mémoire non-utilisé.
+ memory_analysis.append( a.capacity() - a.size() );
}
// Affichage de quelques statistiques sur l'expérience.
@@ -36,9 +40,10 @@ int main(int argc, char ** argv){
std::cerr<<"Variance :"<<time_analysis.get_variance()<<std::endl;
std::cerr<<"Standard deviation :"<<time_analysis.get_standard_deviation()<<std::endl;
- // Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
+ // Sauvegarde les données de l'expérience.
time_analysis.save_values("../dynamic_array_time_cpp.plot");
copy_analysis.save_values("../dynamic_array_copy_cpp.plot");
+ memory_analysis.save_values("../dynamic_array_memory_cpp.plot");
return 0;
}
diff --git a/TP1/Java/ArrayListProxy.java b/TP1/Java/ArrayListProxy.java
index f2d7bbc..e71393b 100644
--- a/TP1/Java/ArrayListProxy.java
+++ b/TP1/Java/ArrayListProxy.java
@@ -67,10 +67,19 @@ public class ArrayListProxy<T> {
Complexité en temps/espace, pire cas : O(1)
@returns le nombre d'éléments stockés dans le tableau.
*/
- int get_size(){
+ int size(){
return data.size();
}
+ /**
+ Renvoie la capacité de stockage du tableau.
+ Complexité en temps/espace, pire cas : O(1)
+ @returns le nombre d'éléments stockés dans le tableau.
+ */
+ int capacity(){
+ return capacity;
+ }
+
/**
Cette fonction détermine la règle selon laquelle un espace mémoire plus grand sera alloué ou non.
@returns true si le tableau doit être agrandi, false sinon.
diff --git a/TP1/Java/Main.java b/TP1/Java/Main.java
index f504dd5..2b138c0 100644
--- a/TP1/Java/Main.java
+++ b/TP1/Java/Main.java
@@ -10,6 +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();
long before, after;
// Booléen permettant de savoir si une allocation a été effectuée.
boolean memory_allocation;
@@ -26,6 +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() );
}
// Affichage de quelques statistiques sur l'expérience.
@@ -37,6 +41,6 @@ public class Main {
// Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
time_analysis.save_values("../dynamic_array_time_java.plot");
copy_analysis.save_values("../dynamic_array_copy_java.plot");
-
+ memory_analysis.save_values("../dynamic_array_memory_java.plot");
}
}
--
GitLab