Index: trunk/src/l1cache.cpp
===================================================================
--- trunk/src/l1cache.cpp	(revision 12)
+++ trunk/src/l1cache.cpp	(revision 16)
@@ -19,6 +19,20 @@
     miss_info = false;
     hit_info = false;
+    
+   
+    // Est-ce que des élements sont chargés dans ce cache, et prêts à être envoyés ? 
+    Address *head = processing_queue->get_next_ready(); 
+    if (head != NULL) // oui
+    {
+        cout << "has ready elements  : " << *head <<  endl;
+        cstore->do_load(*head);
 
-    if (in_activate) {
+        // Envoi de la réponse au processeur
+        RawAddress req(head->as_absolute());
+        out_activate = true;
+        out_data = req;
+
+    // Sinon, est-ce qu'on est en train de faire une requête ?
+    } else if (in_activate) {
 
         // Retrieves the address
@@ -26,4 +40,13 @@
         Address element(req, cstore->get_line_width());
 
+        // 
+        //  XXX FIXME A PARTIR d'ICI C'EST N'IMPORTE QUOI
+        //
+        //  rappel : processing queue c'est le chargement interne. Si un élement
+        //  est déjà chargé dans le cache, il va dans la processing queue,
+        //  sinon, il part en requete dans le L2
+        //
+        //  ca m'apprendra a faire du copier coller et commiter sans verifier
+        //
         // Si la donnée est chargée dans le cache
         if (cstore->is_loaded(element)) {
@@ -33,5 +56,4 @@
             // affichage de l'action
             cout << sc_time_stamp() << " L1Cache : access to loaded data [" << element << "]  -> hit" << endl;
-
 
             hit_info = true;
@@ -46,19 +68,12 @@
             processing_queue->print();
         }
+
+        //
+        // XXX JUSQU'A ICI, C'est N'IMPORTE QUOI
+        //
     }
 
-    Address *head = processing_queue->get_next_ready(); 
-    if (head != NULL)
-    {
-        cout << "has ready elements " << endl;
-        //processing_queue->print();
-
-        cstore->do_load(*head);
-
-        // Envoi de la réponse au processeur
-        RawAddress req(head->as_absolute());
-        out_activate = true;
-        out_data = req;
-    } else if (! in_activate) {
+    
+    if (!in_activate && processing_queue->is_empty()) {
         out_activate = false;
     }
Index: trunk/src/main.cpp
===================================================================
--- trunk/src/main.cpp	(revision 12)
+++ trunk/src/main.cpp	(revision 16)
@@ -25,4 +25,6 @@
     sc_signal<bool> l1hit_info;
 
+    sc_signal<bool> make_report;
+
     Processor processor("Processor", argv[1]);
     L1Cache   l1cache("L1Cache", 256, TAILLE_LIGNE, FULLY_ASSOCIATIVE, 2);
@@ -46,4 +48,6 @@
 
 
+    processor.simulation_terminate(make_report);
+    monitor.activate(make_report);
 
     l1cache.hit_info(l1hit_info);
Index: trunk/src/monitor.cpp
===================================================================
--- trunk/src/monitor.cpp	(revision 12)
+++ trunk/src/monitor.cpp	(revision 16)
@@ -18,9 +18,10 @@
 void Monitor::make_my_report()
 {
-    cout << dec << endl <<
-        "Report : " << endl << 
-        "L1 total requests : " << l1hits + l1misses << endl <<
-        "         hits     : " << l1hits << endl << 
-        "         misses   : " << l1misses << endl;
-
+    if (activate) {
+        cout << dec << endl <<
+            "Report : " << endl << 
+            "L1 total requests : " << l1hits + l1misses << endl <<
+            "         hits     : " << l1hits << endl << 
+            "         misses   : " << l1misses << endl;
+    }
 }
Index: trunk/src/monitor.h
===================================================================
--- trunk/src/monitor.h	(revision 12)
+++ trunk/src/monitor.h	(revision 16)
@@ -6,9 +6,11 @@
     int l1hits;
 
-    //sc_in<bool> make_report;
+    sc_in_clk clock;
 
     sc_in<bool> l1miss_signal;
     sc_in<bool> l1hit_signal;
-    sc_in_clk clock;
+
+    sc_in<bool> activate;
+
 
     void count_hit();
@@ -22,11 +24,11 @@
 
         SC_METHOD(make_my_report);
-        sensitive << clock;
+        sensitive << activate;
 
         SC_METHOD(count_hit);
-        sensitive << clock.neg();
+        sensitive << clock.pos();
 
         SC_METHOD(count_miss);
-        sensitive << clock.neg();
+        sensitive << clock.pos();
     }
 };
Index: trunk/src/processing_queue.cpp
===================================================================
--- trunk/src/processing_queue.cpp	(revision 12)
+++ trunk/src/processing_queue.cpp	(revision 16)
@@ -39,4 +39,10 @@
     }
 }
+
+bool ProcessingQueue::is_empty()
+{
+    return elements.empty();
+}
+
 
 void ProcessingQueue::mark_ready(Address &element)
Index: trunk/src/processing_queue.h
===================================================================
--- trunk/src/processing_queue.h	(revision 12)
+++ trunk/src/processing_queue.h	(revision 16)
@@ -71,4 +71,6 @@
         Address* get_next_ready();
 
+        bool is_empty();
+
         // Updates the timeout of all internal requests
         void update_time();
Index: trunk/src/processor.cpp
===================================================================
--- trunk/src/processor.cpp	(revision 12)
+++ trunk/src/processor.cpp	(revision 16)
@@ -1,11 +1,14 @@
 #include "processor.h"
 
+
+// Pilote du simulateur
+// lit une addresse dans un fichier si il y a encore des addresses
+// à lire et si la file d'attente n'est pas pleine
 void Processor::driver()
 {
+    out_activate = false;
+
     // Si il y a encore des addresses à envoyer
     if (!file.eof()) {
-
-        // On active le composant recepteur
-        out_activate = true;
 
         // Et que la file n'est pas pleine, alors on les envoie
@@ -22,5 +25,4 @@
             
             if (file.eof()){
-                out_activate = false;
                 return;
             }
@@ -36,25 +38,27 @@
             queue->insert(*addr);
 
+            // Lecture :
+            out_data = address;
+            out_activate = true;
             read(*addr, &data);
+
         }
+        //
         // Si la file est pleine, il faudra attendre un cycle dans la même
         // position
     }
-    // Si il n'y a plus d'addresses à envoyer, on désactive la réception du
-    // coté cache l1.
-    else {
-        // FIXME normalement, c'est superflu
-        // on désactive la reception du coté du cache L1
-        out_activate = false;
-    }
 }
 
+// Est appelée lorsqu'une réponse depuis le cache L1 est envoyée.
 void Processor::completed()
 {
     if (in_activate) {
+        cout << "processeur activé" << endl;
         cout << sc_time_stamp() << " Processor : la donnée " << in_data << " est arrivée" << endl;
         //queue->print();
         RawAddress address = in_data;
         queue->remove(address);
+        cout << "--------------- processeur : état de la queue : " << endl;
+        queue->print();
     }
 }
@@ -64,4 +68,5 @@
     // ici, if ready
     out_data = address;
+    out_activate = true;
 }
 
Index: trunk/src/processor.h
===================================================================
--- trunk/src/processor.h	(revision 12)
+++ trunk/src/processor.h	(revision 16)
@@ -26,4 +26,6 @@
     sc_out<RawAddress> out_data;
     sc_out<bool> out_activate;
+
+    sc_out<bool> simulation_terminate;
 
     // donnée retournée par le cache L1
Index: trunk/src/queue.h
===================================================================
--- trunk/src/queue.h	(revision 12)
+++ trunk/src/queue.h	(revision 16)
@@ -64,14 +64,16 @@
     
     cout << "\t" << "QUEUE suppression de " << element <<  endl;
-
+    int num = elements.erase(element);
+    cout << "nombre d'elements supprimes = " << num << endl;
+/*
     if (elements.size() > 1) {
         typename std::set<T>::iterator it;
         it = elements.find(element);
         if (it != elements.end())
-            elements.erase(it);
+            elements.erase(element);
         else
             std::cerr << "removal ignored" << std::endl;
     }
-
+*/
 //    if (elements.size() > 0) {
 //        std::cout << "QUEUE : j'efface l'element : " << element << std::endl;