[2] | 1 | #include "l1cache.h" |
---|
| 2 | |
---|
| 3 | |
---|
| 4 | void L1Cache::read() |
---|
| 5 | { |
---|
| 6 | // On donne la priorité aux éléments en attente : |
---|
| 7 | // - si des éléments sont présents dans la file d'attente |
---|
| 8 | // on les envoie |
---|
| 9 | // - TODO on doit pouvoir les packer pour pouvoir les envoyer par deux |
---|
| 10 | // - si aucun élément n'est présent dans la liste, on arrête d'envoyer (in_activate = false) |
---|
| 11 | // indépendemment, |
---|
| 12 | // - si on recoit un élement, on regarde s'il est chargé dans le cache: |
---|
| 13 | // - si il est chargé, on le place dans la liste des addresses à envoyer, |
---|
| 14 | // on attend un moment timeout avant de l'envoyer |
---|
| 15 | // - si il n'est pas chargé, on envoit une requete au cache L2, |
---|
| 16 | // on le place dans la liste des addresses à envoyer. |
---|
| 17 | // - XXX le timeout devrait peut etre etre effectué, meme pour les données non présentes dans le L1 |
---|
| 18 | |
---|
| 19 | miss_info = false; |
---|
| 20 | hit_info = false; |
---|
[16] | 21 | |
---|
| 22 | |
---|
| 23 | // Est-ce que des élements sont chargés dans ce cache, et prêts à être envoyés ? |
---|
| 24 | Address *head = processing_queue->get_next_ready(); |
---|
| 25 | if (head != NULL) // oui |
---|
| 26 | { |
---|
| 27 | cout << "has ready elements : " << *head << endl; |
---|
| 28 | cstore->do_load(*head); |
---|
[2] | 29 | |
---|
[16] | 30 | // Envoi de la réponse au processeur |
---|
| 31 | RawAddress req(head->as_absolute()); |
---|
| 32 | out_activate = true; |
---|
| 33 | out_data = req; |
---|
[2] | 34 | |
---|
[16] | 35 | // Sinon, est-ce qu'on est en train de faire une requête ? |
---|
| 36 | } else if (in_activate) { |
---|
| 37 | |
---|
[2] | 38 | // Retrieves the address |
---|
| 39 | RawAddress req = in_data; |
---|
| 40 | Address element(req, cstore->get_line_width()); |
---|
| 41 | |
---|
[16] | 42 | // |
---|
| 43 | // XXX FIXME A PARTIR d'ICI C'EST N'IMPORTE QUOI |
---|
| 44 | // |
---|
| 45 | // rappel : processing queue c'est le chargement interne. Si un élement |
---|
| 46 | // est déjà chargé dans le cache, il va dans la processing queue, |
---|
| 47 | // sinon, il part en requete dans le L2 |
---|
| 48 | // |
---|
| 49 | // ca m'apprendra a faire du copier coller et commiter sans verifier |
---|
| 50 | // |
---|
[2] | 51 | // Si la donnée est chargée dans le cache |
---|
| 52 | if (cstore->is_loaded(element)) { |
---|
| 53 | |
---|
| 54 | out_activate = true; |
---|
| 55 | |
---|
| 56 | // affichage de l'action |
---|
| 57 | cout << sc_time_stamp() << " L1Cache : access to loaded data [" << element << "] -> hit" << endl; |
---|
| 58 | |
---|
| 59 | hit_info = true; |
---|
| 60 | out_data = in_data; |
---|
| 61 | } else { |
---|
| 62 | |
---|
| 63 | // affichage de l'action |
---|
| 64 | cout << sc_time_stamp() << " L1Cache : access to loaded data [" << element << "] -> miss" << endl; |
---|
| 65 | |
---|
| 66 | miss_info = true; |
---|
| 67 | processing_queue->insert(element, latency); |
---|
| 68 | processing_queue->print(); |
---|
| 69 | } |
---|
[16] | 70 | |
---|
| 71 | // |
---|
| 72 | // XXX JUSQU'A ICI, C'est N'IMPORTE QUOI |
---|
| 73 | // |
---|
[2] | 74 | } |
---|
| 75 | |
---|
[16] | 76 | |
---|
| 77 | if (!in_activate && processing_queue->is_empty()) { |
---|
[2] | 78 | out_activate = false; |
---|
| 79 | } |
---|
| 80 | |
---|
| 81 | processing_queue->update_time(); |
---|
| 82 | |
---|
| 83 | } |
---|
| 84 | |
---|
| 85 | |
---|
| 86 | void L1Cache::write() |
---|
| 87 | { |
---|
| 88 | // cout << sc_time_stamp() << " L1Cache.write()" << endl; |
---|
| 89 | } |
---|