source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_genMoore.cpp @ 104

Last change on this file since 104 was 104, checked in by rosiere, 15 years ago

Fix Bug :
1) Load Store Unit : check big endian
2) Commit unit & RAT : add retire_event interface
  • Property svn:keywords set to Id
File size: 11.5 KB
Line 
1#ifdef SYSTEMC
2//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
3/*
4 * $Id: Load_store_unit_function_speculative_load_commit_genMoore.cpp 104 2009-01-21 21:53:13Z rosiere $
5 *
6 * [ Description ]
7 *
8 */
9
10#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Load_store_unit.h"
11
12namespace morpheo                    {
13namespace behavioural {
14namespace core {
15namespace multi_execute_loop {
16namespace execute_loop {
17namespace multi_execute_unit {
18namespace execute_unit {
19namespace load_store_unit {
20
21
22#undef  FUNCTION
23#define FUNCTION "Load_store_unit::function_speculative_load_commit_genMoore"
24  void Load_store_unit::function_speculative_load_commit_genMoore (void)
25  {
26    log_begin(Load_store_unit,FUNCTION);
27    log_function(Load_store_unit,FUNCTION,_name.c_str());
28
29    // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
30
31    Tcontext_t         memory_out_context_id    = 0;
32    Tcontext_t         memory_out_front_end_id  = 0;
33    Tcontext_t         memory_out_ooo_engine_id = 0;
34    Tpacket_t          memory_out_packet_id     = 0;
35    Tcontrol_t         memory_out_write_rd      = 0;
36    Tgeneral_address_t memory_out_num_reg_rd    = 0;
37    Tgeneral_data_t    memory_out_data_rd       = 0;
38//  Tcontrol_t         memory_out_write_re      = 0;
39//  Tspecial_address_t memory_out_num_reg_re    = 0;
40//  Tspecial_data_t    memory_out_data_re       = 0;
41    Texception_t       memory_out_exception     = 0;
42
43    internal_MEMORY_OUT_VAL = 0;
44
45    // Test store and load queue
46
47    log_printf(TRACE,Load_store_unit,FUNCTION,"  * Test MEMORY_OUT");
48
49    log_printf(TRACE,Load_store_unit,FUNCTION,"    * Load  queue");
50    for (internal_MEMORY_OUT_PTR=0; internal_MEMORY_OUT_PTR<_param->_size_load_queue; internal_MEMORY_OUT_PTR++)
51//     for (uin32_t i=0; (i<_param->_size_load_queue) and not (find_load); i++)
52      {
53//      internal_MEMORY_OUT_PTR = (reg_LOAD_QUEUE_PTR_READ+1)%_param->_size_load_queue;
54        internal_MEMORY_OUT_VAL = ((_load_queue[internal_MEMORY_OUT_PTR]._state == LOAD_QUEUE_COMMIT_CHECK) or
55                                   (_load_queue[internal_MEMORY_OUT_PTR]._state == LOAD_QUEUE_COMMIT));
56       
57        if (internal_MEMORY_OUT_VAL)
58          {
59            log_printf(TRACE,Load_store_unit,FUNCTION,"    * find : %d",internal_MEMORY_OUT_PTR);
60            internal_MEMORY_OUT_SELECT_QUEUE = (_load_queue[internal_MEMORY_OUT_PTR]._state == LOAD_QUEUE_COMMIT_CHECK)?SELECT_LOAD_QUEUE_SPECULATIVE:SELECT_LOAD_QUEUE;
61           
62            memory_out_context_id    = _load_queue [internal_MEMORY_OUT_PTR]._context_id;
63            memory_out_front_end_id  = _load_queue [internal_MEMORY_OUT_PTR]._front_end_id;
64            memory_out_ooo_engine_id = _load_queue [internal_MEMORY_OUT_PTR]._ooo_engine_id;
65            memory_out_packet_id     = _load_queue [internal_MEMORY_OUT_PTR]._packet_id ;
66            memory_out_write_rd      = _load_queue [internal_MEMORY_OUT_PTR]._write_rd  ;
67            memory_out_num_reg_rd    = _load_queue [internal_MEMORY_OUT_PTR]._num_reg_rd;
68
69            Tdcache_data_t data_old = _load_queue [internal_MEMORY_OUT_PTR]._rdata;
70            Tdcache_data_t data_new = extend<Tdcache_data_t>(_param->_size_general_data,
71                                                             data_old >> _load_queue [internal_MEMORY_OUT_PTR]._shift,
72                                                             _load_queue [internal_MEMORY_OUT_PTR]._is_load_signed,
73                                                             _load_queue [internal_MEMORY_OUT_PTR]._access_size);
74            log_printf(TRACE,Load_store_unit,FUNCTION,"    * data (old) : %.8x",data_old);
75            log_printf(TRACE,Load_store_unit,FUNCTION,"    * data (new) : %.8x",data_new);
76            log_printf(TRACE,Load_store_unit,FUNCTION,"      * address      : %.8x",_load_queue [internal_MEMORY_OUT_PTR]._address);
77            log_printf(TRACE,Load_store_unit,FUNCTION,"      * rdata        : %.8x",_load_queue [internal_MEMORY_OUT_PTR]._rdata);
78            log_printf(TRACE,Load_store_unit,FUNCTION,"      * shift        : %d",_load_queue [internal_MEMORY_OUT_PTR]._shift);
79            log_printf(TRACE,Load_store_unit,FUNCTION,"      * signed?      : %d",_load_queue [internal_MEMORY_OUT_PTR]._is_load_signed);
80            log_printf(TRACE,Load_store_unit,FUNCTION,"      * access_size  : %d",_load_queue [internal_MEMORY_OUT_PTR]._access_size);
81
82            Texception_t exception      = _load_queue [internal_MEMORY_OUT_PTR]._exception;
83            bool         have_exception = ((exception != EXCEPTION_MEMORY_NONE) and
84                                           (exception != EXCEPTION_MEMORY_MISS_SPECULATION));
85
86            // if exception, rdata content the address of load, else content read data.
87            memory_out_data_rd       = (have_exception)?data_old:data_new;
88            memory_out_exception     = (_load_queue[internal_MEMORY_OUT_PTR]._state == LOAD_QUEUE_COMMIT_CHECK)?EXCEPTION_MEMORY_LOAD_SPECULATIVE:exception;
89
90            log_printf(TRACE,Load_store_unit,FUNCTION,"      * exception    : %d",exception);
91            log_printf(TRACE,Load_store_unit,FUNCTION,"      * exception    : %d",memory_out_exception);
92
93            break; // we have find a entry !!! stop the search
94          }
95      }
96
97    if (not internal_MEMORY_OUT_VAL)
98      {
99        log_printf(TRACE,Load_store_unit,FUNCTION,"    * Store queue");
100        if (_store_queue [reg_STORE_QUEUE_PTR_READ]._state == STORE_QUEUE_COMMIT)
101          {
102            log_printf(TRACE,Load_store_unit,FUNCTION,"    * find : %d",reg_STORE_QUEUE_PTR_READ);
103
104            internal_MEMORY_OUT_VAL          = 1;
105            internal_MEMORY_OUT_SELECT_QUEUE = SELECT_STORE_QUEUE;
106           
107            memory_out_context_id    = _store_queue [reg_STORE_QUEUE_PTR_READ]._context_id;
108            memory_out_front_end_id  = _store_queue [reg_STORE_QUEUE_PTR_READ]._front_end_id;
109            memory_out_ooo_engine_id = _store_queue [reg_STORE_QUEUE_PTR_READ]._ooo_engine_id;
110            memory_out_packet_id     = _store_queue [reg_STORE_QUEUE_PTR_READ]._packet_id ;
111//          memory_out_write_rd         
112//          memory_out_num_reg_rd       
113            memory_out_data_rd       = _store_queue [reg_STORE_QUEUE_PTR_READ]._address; // to the exception
114            memory_out_exception     = _store_queue [reg_STORE_QUEUE_PTR_READ]._exception;
115          }
116      }
117    // write output
118    PORT_WRITE(out_MEMORY_OUT_VAL          [0], internal_MEMORY_OUT_VAL);
119
120    if (_param->_have_port_context_id)
121    PORT_WRITE(out_MEMORY_OUT_CONTEXT_ID   [0], memory_out_context_id   );
122    if (_param->_have_port_front_end_id)
123    PORT_WRITE(out_MEMORY_OUT_FRONT_END_ID [0], memory_out_front_end_id );
124    if (_param->_have_port_ooo_engine_id)
125    PORT_WRITE(out_MEMORY_OUT_OOO_ENGINE_ID[0], memory_out_ooo_engine_id);
126    if (_param->_have_port_rob_ptr)
127    PORT_WRITE(out_MEMORY_OUT_PACKET_ID    [0], memory_out_packet_id    );
128//  PORT_WRITE(out_MEMORY_OUT_OPERATION    [0], memory_out_operation    );
129//  PORT_WRITE(out_MEMORY_OUT_TYPE         [0], TYPE_MEMORY             );
130    PORT_WRITE(out_MEMORY_OUT_WRITE_RD     [0], memory_out_write_rd     );
131    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RD   [0], memory_out_num_reg_rd   );
132    PORT_WRITE(out_MEMORY_OUT_DATA_RD      [0], memory_out_data_rd      );
133//  PORT_WRITE(out_MEMORY_OUT_WRITE_RE     [0], memory_out_write_re     );
134//  PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   [0], memory_out_num_reg_re   );
135//  PORT_WRITE(out_MEMORY_OUT_DATA_RE      [0], memory_out_data_re      );
136    PORT_WRITE(out_MEMORY_OUT_WRITE_RE     [0], 0);
137    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   [0], 0);
138    PORT_WRITE(out_MEMORY_OUT_DATA_RE      [0], 0);
139    PORT_WRITE(out_MEMORY_OUT_EXCEPTION    [0], memory_out_exception    );
140    PORT_WRITE(out_MEMORY_OUT_NO_SEQUENCE  [0], 0);
141    PORT_WRITE(out_MEMORY_OUT_ADDRESS      [0], 0);
142
143    // ~~~~~[ Interface "dache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
144
145    Tcontext_t        dcache_req_context_id;
146    Tpacket_t         dcache_req_packet_id ;
147    Tdcache_address_t dcache_req_address   ;
148    Tdcache_type_t    dcache_req_type      ;
149    Tdcache_data_t    dcache_req_wdata     ;
150
151    log_printf(TRACE,Load_store_unit,FUNCTION,"  * Test DCACHE_REQ");
152
153    internal_DCACHE_REQ_VAL = 0;
154
155    internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ = (*_speculative_access_queue_control)[0];
156
157    // Test store and load queue
158    if (_speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._state == SPECULATIVE_ACCESS_QUEUE_WAIT_CACHE)
159      {
160        log_printf(TRACE,Load_store_unit,FUNCTION,"    * speculative_access_queue [%d]",internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ);
161
162        internal_DCACHE_REQ_VAL          = 1;
163        internal_DCACHE_REQ_SELECT_QUEUE = SELECT_LOAD_QUEUE_SPECULATIVE;
164
165        if (_param->_have_port_dcache_context_id)
166          {
167            Tcontext_t context_id    = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._context_id;
168            Tcontext_t front_end_id  = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._front_end_id;
169            Tcontext_t ooo_engine_id = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._ooo_engine_id;
170           
171            dcache_req_context_id = ((ooo_engine_id<<(_param->_size_context_id + _param->_size_front_end_id )) |
172                                     (front_end_id <<(_param->_size_context_id)) |
173                                     (context_id));
174          }
175
176        dcache_req_packet_id  = DCACHE_REQ_IS_LOAD(_speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._load_queue_ptr_write);
177        dcache_req_address    = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._address;// & _param->_mask_address_msb;
178        dcache_req_type       = operation_to_dcache_type(_speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._operation);
179
180//      log_printf(TRACE,Load_store_unit,FUNCTION,"      * address            : %.8x",_speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._address);
181//      log_printf(TRACE,Load_store_unit,FUNCTION,"      * mask               : %.8x",_param->_mask_address_msb);
182        log_printf(TRACE,Load_store_unit,FUNCTION,"      * dcache_req_address : %.8x",dcache_req_address);
183
184#ifdef SYSTEMC_VHDL_COMPATIBILITY
185        dcache_req_wdata      = 0;
186#endif
187      }
188    else
189      {
190        // Test an store must be commited.
191        if (_store_queue [reg_STORE_QUEUE_PTR_READ]._state == STORE_QUEUE_VALID_NO_SPECULATIVE)
192          {
193            internal_DCACHE_REQ_VAL          = 1;
194            internal_DCACHE_REQ_SELECT_QUEUE = SELECT_STORE_QUEUE;
195           
196            if (_param->_have_port_dcache_context_id)
197              {
198                Tcontext_t context_id    = _store_queue [reg_STORE_QUEUE_PTR_READ]._context_id;
199                Tcontext_t front_end_id  = _store_queue [reg_STORE_QUEUE_PTR_READ]._front_end_id;
200                Tcontext_t ooo_engine_id = _store_queue [reg_STORE_QUEUE_PTR_READ]._ooo_engine_id;
201               
202                dcache_req_context_id = ((ooo_engine_id<<(_param->_size_context_id + _param->_size_front_end_id )) |
203                                         (front_end_id <<(_param->_size_context_id)) |
204                                         (context_id));
205              }
206
207            // FIXME : il peut avoir plusieurs store avec le même paquet_id ... pour l'instant pas très grave car pas de retour (enfin seul les bus error sont des retours)
208            dcache_req_packet_id  = DCACHE_REQ_IS_STORE(reg_STORE_QUEUE_PTR_READ);
209            dcache_req_address    = _store_queue [reg_STORE_QUEUE_PTR_READ]._address;
210            dcache_req_type       = operation_to_dcache_type(_store_queue [reg_STORE_QUEUE_PTR_READ]._operation);
211            dcache_req_wdata      = _store_queue [reg_STORE_QUEUE_PTR_READ]._wdata;
212          }
213      }
214
215    PORT_WRITE(out_DCACHE_REQ_VAL       [0], internal_DCACHE_REQ_VAL);
216    if (_param->_have_port_dcache_context_id)
217    PORT_WRITE(out_DCACHE_REQ_CONTEXT_ID[0], dcache_req_context_id);
218    PORT_WRITE(out_DCACHE_REQ_PACKET_ID [0], dcache_req_packet_id );
219    PORT_WRITE(out_DCACHE_REQ_ADDRESS   [0], dcache_req_address   );
220    PORT_WRITE(out_DCACHE_REQ_TYPE      [0], dcache_req_type      );
221    PORT_WRITE(out_DCACHE_REQ_WDATA     [0], dcache_req_wdata     );
222   
223    log_end(Load_store_unit,FUNCTION);
224  };
225
226}; // end namespace load_store_unit
227}; // end namespace execute_unit
228}; // end namespace multi_execute_unit
229}; // end namespace execute_loop
230}; // end namespace multi_execute_loop
231}; // end namespace core
232
233}; // end namespace behavioural
234}; // end namespace morpheo             
235#endif
236//#endif
Note: See TracBrowser for help on using the repository browser.