ruby/system/GPUCoalescer.cc

120       issueEvent([this]{ completeIssue(); }, "Issue coalesced request",
166         GPUCoalescerRequest* request = read->second;
167         if (current_time - request->issue_time < m_deadlock_threshold)
171              "version: %d request.paddr: 0x%x m_readRequestTable: %d "
173               request->pkt->getAddr(), m_readRequestTable.size(),
174               current_time * clockPeriod(), request->issue_time * clockPeriod(),
175               (current_time - request->issue_time)*clockPeriod());
181         GPUCoalescerRequest* request = write->second;
182         if (current_time - request->issue_time < m_deadlock_threshold)
186              "version: %d request.paddr: 0x%x m_writeRequestTable: %d "
188               request->pkt->getAddr(), m_writeRequestTable.size(),
189               current_time * clockPeriod(), request->issue_time * clockPeriod(),
190               (current_time - request->issue_time) * clockPeriod());
260         // Check if there is any outstanding read request for the same
268           // There is an outstanding write request for the cache line
273         // Check if there is any outstanding write request for the same
281             // There is an outstanding read request for the cache line
309 // Insert the request on the correct request table.  Return true if
349                     "Inserting write request for paddr %#x for type %d\n",
365                     "Inserting read request for paddr %#x for type %d\n",
412 GPUCoalescer::handleLlsc(Addr address, GPUCoalescerRequest* request)
420     if (request->m_type == RubyRequestType_Store_Conditional) {
426             request->pkt->req->setExtraData(0);
433             request->pkt->req->setExtraData(1);
439     } else if (request->m_type == RubyRequestType_Load_Linked) {
498     GPUCoalescerRequest* request = i->second;
503     assert((request->m_type == RubyRequestType_ST) ||
504            (request->m_type == RubyRequestType_ATOMIC) ||
505            (request->m_type == RubyRequestType_ATOMIC_RETURN) ||
506            (request->m_type == RubyRequestType_ATOMIC_NO_RETURN) ||
507            (request->m_type == RubyRequestType_RMW_Read) ||
508            (request->m_type == RubyRequestType_RMW_Write) ||
509            (request->m_type == RubyRequestType_Load_Linked) ||
510            (request->m_type == RubyRequestType_Store_Conditional) ||
511            (request->m_type == RubyRequestType_Locked_RMW_Read) ||
512            (request->m_type == RubyRequestType_Locked_RMW_Write) ||
513            (request->m_type == RubyRequestType_FLUSH));
524         success = handleLlsc(address, request);
526     if (request->m_type == RubyRequestType_Locked_RMW_Read) {
528     } else if (request->m_type == RubyRequestType_Locked_RMW_Write) {
532     hitCallback(request, mach, data, success,
533                 request->issue_time, forwardRequestTime, firstResponseTime,
580     GPUCoalescerRequest* request = i->second;
585     assert((request->m_type == RubyRequestType_LD) ||
586            (request->m_type == RubyRequestType_IFETCH));
588     hitCallback(request, mach, data, true,
589                 request->issue_time, forwardRequestTime, firstResponseTime,
684 // Analyzes the packet to see if this request can be coalesced.
685 // If request can be coalesced, this request is added to the reqCoalescer table
687 // If this is the first request to a cacheline, request is added to both
690 // If there is a pending request to this cacheline and this request
798                 // If we reached here, this request must be a memFence
825     // Check if there is any pending request to this cache line from
827     // If there is a pending request, return aliased. Since coalescing
829     // If a request for this address has already been issued, we must block
836     // Check if this request can be coalesced with previous
840         // A new request to the memory subsystem has to be
845     // There was a request to this cache line in this cycle,
846     // let us see if we can coalesce this request with the previous
863     // in addition to the packet, we need to save both request types
880     // If valid, copy the pc to the ruby request
976         << ", read request table: " << m_readRequestTable
977         << ", write request table: " << m_writeRequestTable
1006         // first request for each cacheline, the remaining requests
1007         // can be coalesced with the first request. So, only
1008         // one request is issued per cacheline.
1013         // Insert this request to the read/writeRequestTables. These tables
1019                   "request is already outstanding\n");
1022         // Issue request to ruby subsystem
1175     GPUCoalescerRequest* request = i->second;
1176     return request->pkt;