Changeset 110 for trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_insert.cpp

Timestamp:

Feb 19, 2009, 5:31:47 PM (15 years ago)

Author:

rosiere

Message:

1) OOO_egine : add stat to depiste low perf source
2) Commit : add stat
3) LSU_Pointer : retire - always ack (else combinatory loop). insert - max nb_inst_memory
4) TopLevel? : add debug_idle_time to stop combinatory loop.
5) Issue_queue : add reexecute_queue, new implementation (routage after issue_queue)
6) Decod / Predictor : add "can_continue"

File:

• trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_insert.cpp (modified) (2 diffs)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_insert.cpp

@@ -22 +22 @@
   void Load_Store_pointer_unit::genMealy_insert (void)
   {
-    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
+    log_begin(Load_Store_pointer_unit,FUNCTION);
+    log_function(Load_Store_pointer_unit,FUNCTION,_name.c_str());
 
-    bool use_lsq [_param->_nb_load_store_queue];
+    // TODO : limité à nb_inst_memory le nombre d'accès par lsq !!!
+
+    uint32_t   nb_use_lsq            [_param->_nb_load_store_queue];
+    Tlsq_ptr_t STORE_QUEUE_PTR_WRITE [_param->_nb_load_store_queue];
+    bool       STORE_QUEUE_USE       [_param->_nb_load_store_queue][_param->_max_size_store_queue];
+    Tlsq_ptr_t STORE_QUEUE_NB_USE    [_param->_nb_load_store_queue];
+    Tlsq_ptr_t LOAD_QUEUE_PTR_WRITE  [_param->_nb_load_store_queue];
+    bool       LOAD_QUEUE_USE        [_param->_nb_load_store_queue][_param->_max_size_load_queue];
+    
     for (uint32_t i=0; i<_param->_nb_load_store_queue; i++)
-      use_lsq [i] = false;
+      {
+        nb_use_lsq            [i] = _param->_nb_inst_memory[i];
+
+        STORE_QUEUE_PTR_WRITE [i] = reg_STORE_QUEUE_PTR_WRITE [i];
+        STORE_QUEUE_NB_USE    [i] = reg_STORE_QUEUE_NB_USE    [i];
+        LOAD_QUEUE_PTR_WRITE  [i] = reg_LOAD_QUEUE_PTR_WRITE  [i];
+        
+        for (uint32_t j=0; j<_param->_size_store_queue[i]; j++)
+          STORE_QUEUE_USE [i][j] = reg_STORE_QUEUE_USE [i][j];
+        for (uint32_t j=0; j<_param->_size_load_queue[i]; j++)
+          LOAD_QUEUE_USE  [i][j] = reg_LOAD_QUEUE_USE  [i][j];
+      }
 
     for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
       {
+        log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * INSERT [%d]",i);
+
         Tcontrol_t ack                   = false;
-        Tlsq_ptr_t store_queue_ptr_write = 0;
-        Tlsq_ptr_t load_queue_ptr_write  = 0;
 
         if ( (PORT_READ(in_INSERT_VAL  [i]) == true       ) and
              (PORT_READ(in_INSERT_TYPE [i]) == TYPE_MEMORY))
           {
+            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * type is memory");
+
             Tcontext_t front_end_id = (_param->_have_port_front_end_id)?PORT_READ(in_INSERT_FRONT_END_ID [i]):0;
             Tcontext_t context_id   = (_param->_have_port_context_id  )?PORT_READ(in_INSERT_CONTEXT_ID   [i]):0;
-            
             uint32_t   lsq          = _param->_link_load_store_unit_with_thread[front_end_id][context_id];
+
+            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * front_end_id : %d",front_end_id);
+            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * context_id   : %d",context_id  );
+            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lsq          : %d",lsq         );
 
             // Test if a previous instruction use the same lsq
             // Authorize once memory access by load store unit
-            if (use_lsq [lsq] == false)
+            if (nb_use_lsq [lsq] > 0)
               {
-                use_lsq [lsq] = true;
+                nb_use_lsq [lsq] --;
 
                 uint32_t   ptr;
-                
-                store_queue_ptr_write   = reg_STORE_QUEUE_PTR_WRITE [lsq];
-                load_queue_ptr_write    = reg_LOAD_QUEUE_PTR_WRITE  [lsq];
+
+                PORT_WRITE(out_INSERT_STORE_QUEUE_PTR_WRITE [i], STORE_QUEUE_PTR_WRITE [lsq]);
+                if (_param->_have_port_load_queue_ptr)
+                PORT_WRITE(out_INSERT_LOAD_QUEUE_PTR_WRITE  [i], LOAD_QUEUE_PTR_WRITE  [lsq]);
+
+                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * sq_ptr_write : %d",STORE_QUEUE_PTR_WRITE [lsq]);
+                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lq_ptr_write : %d",LOAD_QUEUE_PTR_WRITE [lsq]);
                 
                 // operation became of decod_stage. Also operation is != store_head_ok and store_head_ko
                 if (is_operation_memory_store(PORT_READ(in_INSERT_OPERATION [i])))
                   {
+                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * USE_STORE_QUEUE");
+                
                     internal_INSERT_OPERATION_USE [i] = OPERATION_USE_STORE_QUEUE;
                     
-                    ptr = reg_STORE_QUEUE_PTR_WRITE [lsq];
+                    ptr = STORE_QUEUE_PTR_WRITE [lsq];
+                    ack = not STORE_QUEUE_USE [lsq][ptr] and (static_cast<uint32_t>(STORE_QUEUE_NB_USE [lsq]+1) < _param->_size_store_queue[lsq]);
 
-                    ack = not reg_STORE_QUEUE_USE [lsq][ptr] and (static_cast<uint32_t>(reg_STORE_QUEUE_NB_USE [lsq]+1) < _param->_size_store_queue[lsq]);
+                    if (ack)
+                      {
+                        STORE_QUEUE_PTR_WRITE [lsq]      = (ptr+1)%_param->_size_store_queue[lsq];
+                        STORE_QUEUE_NB_USE    [lsq]      ++;
+                        STORE_QUEUE_USE       [lsq][ptr] = true;
+                      }
                   }
                 else
                   {
+                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * USE_LOAD_QUEUE");
+
                     internal_INSERT_OPERATION_USE [i] = OPERATION_USE_LOAD_QUEUE;
                     
-                    ptr = reg_LOAD_QUEUE_PTR_WRITE [lsq];
+                    ptr = LOAD_QUEUE_PTR_WRITE [lsq];
+                    ack = (not LOAD_QUEUE_USE [lsq][ptr]);
 
-                    ack = (not reg_LOAD_QUEUE_USE [lsq][ptr]);
+                    if (ack)
+                      {
+                        LOAD_QUEUE_PTR_WRITE [lsq]      = (ptr+1)%_param->_size_load_queue[lsq];
+                        LOAD_QUEUE_USE       [lsq][ptr] = true;
+                      }
                   }
+
+                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ptr          : %d",ptr         );
+                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ack          : %d",ack         );
                 
                 internal_INSERT_LSQ [i] = lsq;
@@ -85 +132 @@
         internal_INSERT_ACK [i] = ack;
         PORT_WRITE(out_INSERT_ACK                   [i], ack);
-        PORT_WRITE(out_INSERT_STORE_QUEUE_PTR_WRITE [i], store_queue_ptr_write);
-        if (_param->_have_port_load_queue_ptr)
-        PORT_WRITE(out_INSERT_LOAD_QUEUE_PTR_WRITE  [i], load_queue_ptr_write );
       }
 
-    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
+    log_end(Load_Store_pointer_unit,FUNCTION);
   };