Newer
Older
# P4a : Analyse de performances de différentes structures
[Grille d'évaluation P4a](https://docs.google.com/spreadsheets/d/1x72glVEQHPx56Wr8G0RNQgfQXGX6xCsjms_6b7J6si0/edit?usp=sharing
)
## Problème
Définir les diffèrence de performances entre deux ICollection : les LinkedList, les List et les HashSet.
On va étudier les performances sur les deux oppération basique : add et Contains et remove .
Intuitivement : l'accés sur un objet dans une ICollection de 1000 ou 10 000 objet ne sera pas aussi rapide et ne sera pas le même en fonction de la collection utilisé
un program C# usage : testStructur.exe type fonction nbOpp taille
un shell script program.sh qui effectue une boucle imbriqué avec toute les variable de test.
[./program/testStructur.cs](chemin)
testStructur.cs prend 4 argument : type fonction nbOpp taille
type : string, le type de la liste que l'on veux tester.
fonction : string, la fonction que l'on veux tester.
{'Ajout', 'Acces'}
nbOpp : int, le nombre d'opération que l'on veux effectuer.
taill : int, la taille de la liste sur laquel on veux effectuer les opérations.
model name : Intel(R) Xeon(R) CPU E5-2630L v3 @ 1.80GHz
cpu MHz : 2239.379
cache size : 20480 KB
cpu cores : 8
clflush size : 64
cache_alignment : 64
address sizes : 46 bits physical, 48 bits virtual
Description de la démarche systématique et de l'espace d'exploration pour chaque paramètres.
Nous disposont donc de trois paramètres d'exploration sur chaque ICollection.
plus précisement : nous disposons de 2 véritable paramètres exploratoire sur chacune des opération.
paramètres 1 : la taille de la liste initial;
nous explorerons des listes de taille aléatoire entre 1 et 10 000 (x1000) éléments
sur chacune des liste nous effecturont 10 000
(sur les liste de moins de 10000 élément pour le remove on va potentiell en faire moins mais cela ne change pas les résultat)
```
Suite des commandes, ou script, à exécuter pour produire les données.
|----------------------|---------------------------|---------------------------|---------------------------|
| Insertion | ![plot](./program/data/prealable/Linked_add_exectime.png) | ![plot](./program/data/prealable/List_add_exectime.png) | ![plot](./program/data/prealable/HashSet_add_exectime.png) |
| Accès |![plot](./program/data/prealable/Linked_acces_exectime.png) | ![plot](./program/data/prealable/List_acces_exectime.png) | ![plot](./program/data/prealable/HashSet_acces_exectime.png) |
| remove |![plot](./program/data/prealable/Linked_remove_exectime.png) | ![plot](./program/data/prealable/List_remove_exectime.png) | ![plot](./program/data/prealable/HashSet_remove_exectime.png) |
|----------------------|---------------------------|---------------------------|---------------------------|
| Insertion |![plot](./program/data/prealable/Linked_add_memory.png) | ![plot](./program/data/prealable/List_add_memory.png) | ![plot](./program/data/prealable/HashSet_add_memory.png) |
| Accès |![plot](./program/data/prealable/Linked_acces_memory.png) | ![plot](./program/data/prealable/List_acces_memory.png) | ![plot](./program/data/prealable/HashSet_acces_memory.png) |
| remove |![plot](./program/data/prealable/Linked_remove_memory.png) | ![plot](./program/data/prealable/List_remove_memory.png) | ![plot](./program/data/prealable/HashSet_remove_memory.png) |
#### Exectime
Pour les LinkedList, les courbe son assez net pour l'accès et le remove, avec un temps quasiment identique. Cela s'explique facilement par la structures de la linkedList, suprimer un élement est une oppération qui consiste juste a supprimer une référence en mémoire, pas forcément de suprimer l'espace mémoire. pour l'insertion, les donné ne semble pas montré de tendance particulière
pour les List : l'insertion montre quatre réel tendance mais qui n'évolue pas en fonction de la taille; vue le temps extrèmement faible on peux penser à une erreur au niveau du procédé expérimental. Pour l'accès on a une courbe affine bien définit, mais avec une tendance plus rapide (max 4sec) que pour la LinkedList. Pour le remove toujour une courbe affine mais la lest temps explose et on monte à 60sec.
Pour le HashSet, on voit pour les 3 fonctions des tendance clair. et globalement, toujours les même quelque soit la fonction.
#### Memory
Pour les linkedlist, on trouve pour toutes les fonctions les 4 même tendance. sans trop de rapport avec la taille
Pour les list, on trouve les 4 même tendance pour les 3 fonction, mais certaine sont beaucoup plus marqué selon les cas. Pour l'insertion mais beaucoup plus elevé que les Linkedlist (2x plus), c'est les deux tendance les plus élevè. Pour Accès et remove on trouve les même deux tendances, celle du millieu, avec une faible tendance plus élevè et une faible tendance plus faible.
Pour le HashSet, on trouve les 3 même tendance à chaque fois. tendance beaucoup plus faible encore une fois que les autres.
Dans ces tests, on ne test pas avec plusieurs nombre d'oppérations différents. on test tous avec 10 000 opération effectué
## Etude approfondie
### Hypothèse
Expression précise et succincte d'une hypothèse.
### Protocole expérimental de vérification de l'hypothèse
Expression précise et succincte du protocole.
```
Suite des commandes, ou script, à exécuter pour produire les données.
```
### Résultats expérimentaux
### Analyse des résultats expérimentaux
### Discussion des résultats expérimentaux
## Conclusion et travaux futurs