SYS2 last
Section critique
fn() {
a = a + 1;
}
Ici on a aucune garanti qu’entre les thread la valeur de a sera celle qu’on attend
spin lock: on attend jusqu’à ce que ça que ça se delock.
sémaphore: structure de synchro avec une queue
mutex: méchanisme de synchro qui évite que les essources partagés soit utilisées en même temps
on peut faire un mutex avec un sémaphore
synchronized: On va bloquer
Cache
fetch: (*)
decode:
execute:
memory: (*)
writeback:
(*) Operation mémoires
Fetch et mémory vont écrire et lire en cache qui se trouve entre fetch et memory.
Sauf qu’on pourrait avoir un cache dans fetch direct pour aller plus vite ? Mais du coup memory irait plus lentement.
L’idée est donc de rajouter un mini cache dans fetch et memory et un plus gros cache entre les deux.
On va avoir un L1 pour les instruction, un L1 pour les data.
Un cache L2 qui est le coeur.
TLB: Permet a L2 de trouver la bonne adresse dans L3 au moment ou il veut fetch.
Quand le cache est plein et qu’on doit ajouter quelque chose on va souvet utiliser un LRU (least recently used).
Qu’est-ce qu’on a fait
- Rappel réseau (hors sujet)
- File system
- Inode
- Index
- Ext fs
- Fat (parenthèse carte SD)
- Thread
- Mecanisme de synchro
- Scheduling
- Round robin
- Queue
- Multiple leve of priority
- Metric of scheduing (wainting time, response time etc., caching, quantum)
- La caching est une (grosse) parenthèse
- IO / CPU bound
Comment on stock les inodes ? Chaque fichier est un inode. Dans un directory on a des inodes qui conduisent vers les fichiers.
On a une table entre clé et data qui est un btree.
Round robin
Cet algo est preemptif.
On a une queue de process.
Tous les n temps on a un thick, on va passer au process suivant. Le problème c’est que lors d’un syscall on bloue le scheduling. Donc si un process arrive après, il va lui rester le reste du dernier quantum à cause du syscall. Du coup chacun se retrouve avec des restes de précedent à cause de ça.
SYS2 last
Section critique
Ici on a aucune garanti qu’entre les thread la valeur de a sera celle qu’on attend
spin lock: on attend jusqu’à ce que ça que ça se delock.
sémaphore: structure de synchro avec une queue
mutex: méchanisme de synchro qui évite que les essources partagés soit utilisées en même temps
on peut faire un mutex avec un sémaphore
synchronized: On va bloquer
Cache
fetch: (*)
decode:
execute:
memory: (*)
writeback:
Fetch et mémory vont écrire et lire en cache qui se trouve entre fetch et memory.
Sauf qu’on pourrait avoir un cache dans fetch direct pour aller plus vite ? Mais du coup memory irait plus lentement.
L’idée est donc de rajouter un mini cache dans fetch et memory et un plus gros cache entre les deux.
On va avoir un L1 pour les instruction, un L1 pour les data.
Un cache L2 qui est le coeur.
TLB: Permet a L2 de trouver la bonne adresse dans L3 au moment ou il veut fetch.
Quand le cache est plein et qu’on doit ajouter quelque chose on va souvet utiliser un LRU (least recently used).
Qu’est-ce qu’on a fait
Comment on stock les inodes ? Chaque fichier est un inode. Dans un directory on a des inodes qui conduisent vers les fichiers.
On a une table entre clé et data qui est un btree.
Round robin
Cet algo est preemptif.
On a une queue de process.
Tous les n temps on a un thick, on va passer au process suivant. Le problème c’est que lors d’un syscall on bloue le scheduling. Donc si un process arrive après, il va lui rester le reste du dernier quantum à cause du syscall. Du coup chacun se retrouve avec des restes de précedent à cause de ça.