BUT2FI_2026_R3.05/tp/tp5/parallelisme.md

# Signaux

- partie 1 : [Parallèlisme avec processus](parallelisme.md)
- partie 2 : [Signaux](ordonnancement.md)


#### Ex1
On veut écrire un programme calculant la somme des entiers
de `1` à `N` à l’aide de `K` processus enfants. Chaque fils calculera la somme
d’un sous-ensemble de ces entiers et la somme globale sera obtenue en
calculant la somme des résultats intermédiaires de chaque fils. Pour que le pére puisse collecter
les résultats de ses fils, il créera avec mmap un espace partagé avec ses fils :

```c
uint64_t *resultats = (uint64_t*)mmap(NULL, K * sizeof(uint64_t), PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS, -1, 0);
```
> pourquoi est-ce nécessaire ?

Les entiers sont répartis uniformément entre les fils comme suit (exemple avec K=3) :

- Fils 1 : 1, 4, 7, ...
- Fils 2 : 2, 5, 8, ...
- Fils 3 : 3, 6, 9, ...

Bien que les résultats soient connus d'avance (cf votre cours de mathématiques sur les suites arithmétiques), le but 
est de faire effectivement les calculs pour comparer les gains (?) de la parallèlisation.

1. Écrique une fonction 
   ```C
   void slice(uint64_t *res, uint64_t start, uint64_t end,uint64_t step);
   ```
   qui calcule la somme d'une tranche d'entiers, et place le résultat dans `*res`.

2. Complétez le main pour :
   1. Créer les `K` fils
   2. Chaque fils exécute la fonction précedente, avec les bons paramètres.
   3. Le pére attend la fin des fils, collecte leurs résultats intermédiaires, et en 
      fait la somme.

3. Pour une limite `N` assez grande, faites varier le nombre de processus, et construire un graphe
   qui affiche le temps de calcul en fonction du nombre de processus.   
   Qu'observez-vous ?
4. Lancez le processus sur un seul coeur avec `taskset`. Commentaire ?

4. De manière volontaire, faites en sorte que la fonction slice n'utilise pas une variable locale pour
   faire la somme, mais la référence `res`. Recommencez la question 3. Qu'observez-vous ? Pourquoi ?