# SMC Compte Rendu TP6

## Binôme
* Guillaume VACHERIAS : 21204391
* Yann QUERIC : 28712032

## Analyse du composant VciXcacheWrapper

### Question 1
*En moyennant sur plusieurs images, évaluez le nombre de cycles nécessaires pour lire sur disque et afficher une image? Combien cela représente-t-il de cycles par pixel?*

Voici le nombre de cycle pris par image :
| Image | Start cycle | End cycle | Nombre de cycles |
| ----- | ----------- | --------- | ---------------- |
| 1 | 2025 | 202285 | 200260 |
| 2 | 962912 | 1188370 | 225458 |
| 3 | 1948194 | 2186157 | 237963 |
| 4 | 2945981 | 3033609 | 87628 |
| 5 | 3793433 | 3962416 | 168983 |
| 6 | 4722240 | 4907152 | 184912 |
| 7 | 5666976 | 5784600 | 117624 |
| 8 | 6544424 | 6603655 | 59231 |
| 9 | 7363479 | 7418263 | 54784 |
| 10 | 8178087 | 8405899 | 227812 |
| 11 | 9165723 | 9405164 | 239441 |
| 12 | 10164988 | 10385677 | 220689 |
| 13 | 11145867 | 11281746 | 135879 |
| 14 | 12041936 | 12210661 | 168725 |
| 15 | 12970851 | 13080748 | 109897 |
| 16 | 13840938 | 13996672 | 155734 |
| 17 | 14756862 | 14960265 | 203403 |
| 18 | 15720455 | 15822941 | 102486 |
| 19 | 16583131 | 16759909 | 176778 |
| 20 | 17520099 | 17609273 | 89174 |

On calcule alors 158343,05 cycles par images. Nous avons des images de taille 128x128 ce qui fait 16384 pixel 9.66 cycles par pixels.

### Question 2
*Comment est implémenté l'interface entre le contrôleur de cache et l'ISS (Instruction Set Simulator) représentant le processeur?*

On peut retrouver dans l'interface *generic_cache.h* les fonctions utilisés pour interagir avec les lignes de caches. On retrouve les fonctions pour accéder aux valeurs stocké dans une lignes de cache :
* *cache_data*
* *cache_tag*
* *cache_val*

Ensuite, on retrouve les fonctions principales utilisant les fonctions définient précédemment pour effectuer les actions sur les caches (read, update, write, invalidate ...).

Pour le contrôleur de cache et l'IIS, on utilise des automates pour réaliser la simulation. On retrouve 4 automates avec représentants :
* données du cache
* instruction du cache
* commande envoyé
* réponse des commandes

## Automate ICACHE

### Question 3
*Quels sont les conditions de sortie vers les deux états successeurs possibles de l'état IDLE de l'automate ICACHE_FSM ?*

Condition de sortie de *ICACHE_IDLE* est la réception d'un interrupt request valid (**m_ireq.valid**). On retrouve alors 2 cas :
* icache_cacheable : Alors on passe à l'état ICACHE_MISS_SELECT si on a un cache miss
* !icache_cacheable : Alors on passe à l'état ICACHE_UNC_WAIT.

### Question 4
*Comment l'automate ICACHE transmet-il ses requêtes vers l'automate VCI_CMD?*

L'automate ICACHE traîte les requêtes du processeur dans l'état *ICACHE_IDLE*. Si on reçoit une requête valide du processeur avvec une adresse cacheable ainsi qu'un cache hit, on enregistre l'instruction du processeur dans le registre *m_irsp.instruction* qui sera traité plus tard par le l'automate VCI_CMD.

### Question 5
*Si la réponse VCI à une lecture d'instruction signale une erreur d'adressage, comment cette erreur est-elle signalée au processeur?*

Nous utilisons le dernier bit de poid faible de l'adresse stocké dans le registre **p_vci.rerror** pour indiqué si nous reçevons une erreur. Dans le cas où le bit est à 1 (erreur), on met le registre r_vci_rsp_ins_error à true. Cette erreur sera taité dans l'automate ICACHE où l'on remet l'état du ICACHE à IDLE.

### Question 6
*Donner l'expression de la condition irsp.valid (réponse valide à une requête de lecture instruction en provenance du processeur).*

 m_ireq.valid and (m_ireq.addr == r_icache_addr_save.read()) 

### Question 7
*Représentez le graphe des transitions de l'automate ICACHE*


## Automate DCACHE

### Question 1

* *Quelles sont les conditions de sortie vers les six états successeurs possibles de l'état IDLE de l'automate DCACHE_FSM ?*


* *Quelles sont les deux requêtes spéciales (autres que des lectures ou des écritures en mémoire) qui sont acceptées par ce composant ?*
Les 2 requêtes accéptées par ce composant sont LL et SC

### Question 2
*Quelle est l'utilité de l'état DCACHE_MISS_SELECT?*

L'état DCACHE_MISS_SELECT permet la lecture en mémoire des données

### Question 3
* *Si la réponse VCI à une lecture de donnée signale une erreur d'adressage, comment cette erreur est-elle signalée au processeur?*
L'erreur d'une lecture est ignorée est signalé par DCACHE FSM. Plus précisemment, VCI_RSP FSM met le r_vci_rsp_data_error à vrai et la gestion d'erreur se fait par le DCACHE FSM. Le DCACHE_FSM met à l'état DCACHE_IDLE lors d'une erreur

if ( r_vci_rsp_data_error.read() )    // error reported
{
    m_drsp.valid         = true;
    m_drsp.error         = true;
    r_vci_rsp_data_error = false;
    r_dcache_fsm         = DCACHE_IDLE;  
}

* *Comment est signalée une erreur d'adressage suite une écriture ?*
Le VCI_RSP FSM signal l'erreur en utilisant la méthode setWriteBerr().

### Question 4
*Quels sont les états successeurs possibles de l'état DCACHE_WRITE_REQ?*

Les états successeurs possibles de DCACHE_WRITE_REQ sont les mêmes 6 six états sortie de DCACHE_IDLE :
* DCACHE_WRITE_UPDT
* DCACHE_WRITE_REQ
* DCACHE_MISS_SELECT
* DCACHE_UNC_WAIT
* DCACHE_XTN_HIT
* DCACHE__XTN_SYNC

### Question 5
*Donner l'expression de la condition drsp.valid (réponse valide à une requête de lecture ou d'écriture de donnée en provenance du processeur)?*

* Écriture : m_req.valid & DATA_READ & dcache_cacheable & dcache_hit
* Lecture : mreq.valid & DATA_WRITE & dcache_cacheable & dcache_hit

Ainsi pour une lecture ou écriture la condition pour un drsp.valid est un dcache_cacheable et dcache_hit ainsi qu'un req.valid.

### Question 6

## Automate VCI_CMD

### Question 1
* *L'automate VCI_CMD peut être décrit comme un serveur. Quels sont ses clients?*
Les clients du serveurs sont les automates du cache qui ont besoin de faire des commandes VCI :
* DMISS
* INS_MISS
* WRITE
* DUNC
* IUNC

* *Quelle est la politique de priorité implémentée par ce contrôleur en cas de requête simultanée par différents clients?*
Les instructions sont prioritaires et pour les données les écritures sont prioritaires

### Question 2
*Quelles sont les 4 types de transactions VCI qui peuvent être émises par cet automate?*

Les transactions que peuvent être émises par cet automate sont :
* CMD_INS_MISS
* CMD_INS_UNC
* CMD_DATA_MISS
* CMD_DATA_UNC
* CMD_DATA_WRITE

### Question 3 et 5
*Quelles sont les conditions de sortie vers les états successeurs de l'état IDLE?*


### Question 4

*En consultant le code de l'objet write_buffer, expliquez le fonctionnement du tampon d'écritures postées. A quelle condition une transaction d'écriture VCI aura-t-elle une longueur supérieure à un flit?*

* Le tampon d'écritures postées maintient un compteur de transactions en attente, qui est incrémenté chaque fois qu'une nouvelle transaction est ajoutée au tampon.L'objet write_buffer traite les transactions en attente dans l'ordre dans lequel elles ont été reçues. Lorsqu'il est prêt à traiter une transaction, il retire les données correspondantes du tampon d'écritures postées et les utilise pour mettre à jour son état interne.Une fois que la transaction a été traitée, le compteur de transactions en attente est décrémenté et le tampon d'écritures postées est disponible pour stocker de nouvelles transactions.

* La longueur d'une transaction d'écriture VCI dépend de la quantité de données à écrire. Si la quantité de données à écrire est inférieure ou égale à la taille d'un flit, la transaction aura une longueur d'un flit. En revanche, si la quantité de données à écrire est supérieure à la taille d'un flit, la transaction aura une longueur supérieure à un flit et sera divisée en plusieurs flits successifs.

## automate VCI_RSP

### Question 1
*Quelles sont les conditions de sortie vers les états successeurs de l'état IDLE?*

### Question 2
*Comment l'automate VCI_RSP communique-t-il avec les deux automates DCACHE et ICACHE? Comment signale-t-il une éventuelle erreur de lecture reportée par la cible VCI?*

* Il faut synchroniser les états des automates DCACHE et ICACHE pour la terminaison et les erreurs. Pour cela, nous utilisons une bascules RS.

* En cas d'erreur :
* En cas d'erreur d'écriture : l'erreur est directement signalé par RSP FSM.
* **En cas d'erreur lecture écriture** : VCI_RSP FSM met à vrai r_vci_rsp_data_error, flip_flop et l'erreur est signalé par DCACHE_FSM.
* En cas d'erreur d'instruction ; VCI_RSP FSM met à vrai r_vci_rsp_ins_eror, flip_flop et l'erreur est signalé par ICACHE FSM

### Question 3
* *Comment l'automate VCI_RSP signale-t-il la fin d'une transaction d'écriture au tampon d'écritures?*
La fin d'une transaction d'écriture au tampon est signalé par *r_vci_rsp_fifo_ins.wok()* où fifo n'est pas remplis.

* *A quoi sert cette signalisation?*
Cette signalisation sert à indiquer à l'automate VCI_CMD que l'état est synchronisé et qu'on puisse continuer d'envoyer les paquets VCI_CMD.

* *Comment signale-t-il une erreur d'écriture reportée par la cible VCI?*
* En cas d'erreur :
* **En cas d'erreur d'écriture** : l'erreur est directement signalé par RSP FSM.
* En cas d'erreur lecture écriture : VCI_RSP FSM met à vrai r_vci_rsp_data_error, flip_flop et l'erreur est signalé par DCACHE_FSM.
* En cas d'erreur d'instruction ; VCI_RSP FSM met à vrai r_vci_rsp_ins_eror, flip_flop et l'erreur est signalé par ICACHE FSM

## Instrumentation

### Question 1
*Comment est calculé le nombre moyen de cycles par instruction (CPI) ?*
Il est par le nombre total de cycle par le compteur d'excution d'instruction.

<< "- CPI = " << (float)m_cpt_total_cycles/m_cpt_exec_ins << std::endl

### Question 2
*Comment sont calculés le miss_rate (taux de miss) et le miss_cost (coût moyen du miss) pour chacun des deux caches ?*

* Le calcul des Miss Rate :
* Instruction Miss Rate : *(float)m_cpt_ins_miss/m_cpt_exec_ins* (compteur instruction miss par compteur d'exécution d'instruction)
* Données Miss rate : *(float)m_cpt_data_miss/m_cpt_read* (compteur donné miss par compteur de lecture)

* Le calcul des Miss cost. :
* Instruction Miss Cost : *(float)m_cost_ins_miss_frz/m_cpt_ins_miss* (coût instruction miss freezed (non acccepté) par compteur instruction miss)
* Données Miss Cost : *(float)m_cost_data_miss_frz/m_cpt_data_miss* (coût donnée miss freeze (non acccepté) par compteur donnée miss)

### Question 3
* A quoi correspond le write_cost (cout moyen d'écriture) pour le tampon d'écritures postées ?
Le write_cost correspond au nombre de requête non accepté par le nombre de compteur écriture.

* Comment est-il calculé?
On calcule le write cost avec : *(float)m_cost_write_frz/m_cpt_write* (coût écriture freeze par compteur écriture)

## Tampon d'écritures postées

### Question 1
*Quelle est la signification des 4 arguments du constructeur de cet objet ?*
Les 4 arguments du constructeur sont :
* name : Le nom de l'objet
* wbuf_nwords : Le nombre du buffer écriture (buffer width (number of words))
* wbuf_nslots : Le nombre d'emplacement du buffer écriture (buffer depth (number of slots))
* cache_nwords : Le nombre de mot du cache (cache_line width)

### Question 2
* Quels sont les quatre états possibles d'une ligne du multi_write_buffer ?*

* EMPTY: Les emplacements pas encore traité.
* OPEN: Les emplacements sont disponible.
* LOCKED: Les emplacements ne sont pas disponible.
* SENT: Emplacement traité par la fonction sent().

### Question 3
*Quelles sont la ou les méthodes qui peuvent être utilisées par l'automate DCACHE_FSM pour modifier l'état interne du multi_write_buffer ?*

* reset: Remets a l'état EMPTY tout les emplacements
* sent: Utilisé par VCI_CMD FSM et change l'état d'un emplacement de LOCKED à SENT
* update: Appelé à tout les cycles et change l'état d'un emplacement de OPENT à LOCKED
* write: Utilisé par DCACHE FSM et change l'état d'un emplacement de EMPTY à OPEN
* completed: Utilisé par VCI_RSP FSM et change l'état d'un emplacement de SENT à EMPTY

### Question 4
*Quelles sont la ou les méthodes qui peuvent être utilisées par l'automate CMD_FSM pour modifier l'état interne du multi_write_buffer ?*

La seul méthode utilisé par l'automate cmd_fsm est sent() pour modifier l'état interne du buffer.

### Question 5
*Quelles sont la ou les méthodes qui peuvent être utilisées par l'automate RSP_FSM pour modifier l'état interne du multi_write_buffer ?*

La seul méthode utilisé par l'automate cmd_fsm est completed() pour modifier l'état interne du buffer.

### Question 6
*A quoi sert la méthode update() ? Pourquoi doit-elle être appelée à chaque cycle ?*

La méthode update permet de modifier l'état d'un emplacement de open a locked. Elle est appelé à chaque cycle puisque on envoie un paquet VCI a chaque sicle et on est amener a changer et traiter les états d'un emplacements.

## Modification du contrôleur de cache

#### Question 1
*Comparez les fichiers d'interface vci_xcache_wrapper.h et vci_xcache_wrapper_advanced.h, et identifiez les modifications qui ont été introduites*

Dans **dcache_fsm_state_e** du *vci_xcache_wrapper_advanced.h*, nous retrouvons un état DCACHE_XTN_SYNC supplémentaire pour la synchronisation des automates. De plus, nous retrouvons **read_transaction_type_e** qui décrit les types de transaction (DATA_UNC, DATA_MISS, INS_UNC, INS_MISS).

On retrouve en plus dans le fichier *vci_xcache_wrapper.h* le signal **r_dcache_write_req** qui n'est pas présent dans le *vci_xcache_wrapper_advanced.h*.