Soit le [programme](./src/adresses_virtuelles.c) suivant qui affiche les
adresses virtuelles de certaines variables lors de l'exécution du processus
correspondant :
```c
/* adresses virtuelles d'un processus */
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>
int t[1000] = {[0 ... 999] = 2};
int main(int argc, char * argv[])
{
int i=3;
static int j = 3;
char * m = (char*)malloc(1);
printf("je suis le pid %d\n\n",getpid());
/* ------- Affichage des adresses --------*/
printf("main\t=\t%p\n",main);
printf("&argc\t=\t%p\n",&argc);
printf("&i\t=\t%p\n",&i);
printf("&j\t=\t%p\n",&j);
printf("t\t=\t%p\n",t);
printf("m\t=\t%p\n",m);
getchar();
}
```
En utilisant le (pseudo) fichier `/proc/pid/maps`, vérifiez à quel segment de
pages ces adresses appartiennent. Vous pouvez utiliser le script python
[vmap.py](./src/scripts/vmap.py).
#### Ex3
L'interface (pseudo-fichier) `proc/pid/smaps` montre la consommation mémoire
d'un processus. On peut le formater avec la commande `pmap -X` ou avec le script
python [parse_smaps.py](./src/scripts/parse_smaps.py). Le but de l'exercice est
de voir ce qui se passe au niveau de la mémoire d'un processus suivant les
différents mode d'allocation. Le programme `null.c` permet d'avoir un point de
comparaison. Vérifiez la consommation mémoire dans les cas suivants :
1. Allocation statique [buf.c](./src/ex3/buf.c).
2. Allocation sur la pile [stack.c](./src/ex3/stack.c),
3. Allocation sur le tas [heap.c](./src/ex3/heap.c),
4. Allocation (grande quantité) sur le tas [huge.c](./src/ex3/huge.c).
5. Allocation par mapping [mmap.c](./src/ex3/mmap.c).
#### Ex4
Soit le [programme](./src/bss_data.c) suivant :
```c
/* segment bss et data */
#define N 10000
int t[N]; /* version 1 */
//int t[N]={1}; /* version 2 */
int main()
{
return 0;
}
```
1. Compilez le programme. Avec la commande `size`, regardez les différents segments du programme. Où se trouve le tableau `t` ? Augmentez la valeur de N. La taille de l'exécutable a-t-elle changé ? pourquoi ?
2. Recommencez avec la version 2. Expliquez.
#### Ex5
Soit le [programme](./src/ij_ji.c) suivant :
```c
/* accès mémoire */
#include<stdio.h>
#include<time.h>
#include <stdlib.h>
#define N 8192
int t[N][N];
static inline double tstamp(void)
{
struct timespec tv;
clock_gettime(CLOCK_REALTIME, &tv);
return tv.tv_sec + tv.tv_nsec * 1.0e-9;
}
int main()
{
int i,j;
double t1,t2;
t1=tstamp();
/* version 1 */ for(i=0;i<N;i++)for(j=0;j<N;j++)t[i][j]=1;
/* version 2 */ // for(i=0;i<N;i++)for(j=0;j<N;j++)t[j][i]=1;
t2=tstamp();
printf("time = %lf\n",t2-t1);
return 0;
}
```
Le temps d'exécution est-il différent pour les deux versions ? Pourquoi ?
#### Ex6
Le programme [sum_array.c](./src/sum_array.c) calcule la somme des éléments
d'un tableau en accédant aux éléments séquentiellement (`-c` croissant, `-d`
décroissant) ou de manière aléatoire (`-a`) Testez en faisant varier la taille
du tableau. Expliquez .
#### Ex7
On veut implanter un allocateur de mémoire très simple. Un bloc de 8Mo est
reservé à l'aide de la fonction `mmap`. On utilise pour la gestion des demandes
d'allocation la structure suivante :
```c
struct my_memory_buffer {
char* buffer;
size_t pos;
size_t size;
};
```
-`buffer` est l'adresse de la zone reservée par `mmap`.
-`size` est la taille du buffer.
-`pos` permet de garder la trace de ce qui a déjà été alloué.
qui s'occupe de renvoyer l'adresse d'un bloc libre. On ne se préoccupe pas de désallocation, ni d'alignement. Une allocation consiste simplement à incrémenter (si c'est possible)
la valeur de `pos`, et à retourner l'adresse du bloc alloué.
Implanter cette fonction, et tester.
#### Ex8
Ecrire une fonction
```c
void hexdump(void * ptr,size_t size);
```
qui affiche sur la sortie standard le contenu de la mémoire `[ptr,ptr+size[` au format :
