ruby/system/GPUCoalescer.cc

173               request->pkt->getAddr(), m_readRequestTable.size(),
188               request->pkt->getAddr(), m_writeRequestTable.size(),
235 GPUCoalescer::getRequestStatus(PacketPtr pkt, RubyRequestType request_type)
237     Addr line_addr = makeLineAddress(pkt->getAddr());
295 GPUCoalescer::insertKernel(int wavefront_id, PacketPtr pkt)
303     kernelEndList[wavefront_id] = pkt;
312 GPUCoalescer::insertRequest(PacketPtr pkt, RubyRequestType request_type)
314     assert(getRequestStatus(pkt, request_type) == RequestStatus_Ready ||
315            pkt->req->isLockedRMW() ||
328     Addr line_addr = makeLineAddress(pkt->getAddr());
346             i->second = new GPUCoalescerRequest(pkt, request_type,
350                     pkt->req->getPaddr(), i->second->m_type);
362             i->second = new GPUCoalescerRequest(pkt, request_type,
366                     pkt->req->getPaddr(), i->second->m_type);
395     Addr line_addr = makeLineAddress(srequest->pkt->getAddr());
426             request->pkt->req->setExtraData(0);
433             request->pkt->req->setExtraData(1);
603     PacketPtr pkt = srequest->pkt;
604     Addr request_address = pkt->getAddr();
629         PacketPtr pkt = reqCoalescer[request_line_address][i].pkt;
631         request_address = pkt->getAddr();
632         request_line_address = makeLineAddress(pkt->getAddr());
633         if (pkt->getPtr<uint8_t>()) {
641                 pkt->setData(
642                     data.getData(getOffset(request_address), pkt->getSize()));
644                 data.setData(pkt->getPtr<uint8_t>(),
645                              getOffset(request_address), pkt->getSize());
661                 safe_cast<RubyPort::SenderState*>(pkt->senderState);
667         mylist.push_back(pkt);
694 GPUCoalescer::makeRequest(PacketPtr pkt)
700     if (pkt->req->isKernel()) {
701         if (pkt->req->isAcquire()){
705         }else if (pkt->req->isRelease()) {
712             if (pkt->req->hasContextId()) {
713                 wf_id = pkt->req->contextId();
715             insertKernel(wf_id, pkt);
734     if (pkt->isLLSC()) {
743         if (pkt->isWrite()) {
746             assert(pkt->isRead());
750     } else if (pkt->req->isLockedRMW()) {
757         if (pkt->isWrite()) {
760             assert(pkt->isRead());
764     } else if (pkt->isAtomicOp()) {
771         if (pkt->isRead()) {
772             if (pkt->req->isInstFetch()) {
776                 uint32_t flags = pkt->req->getFlags();
789         } else if (pkt->isWrite()) {
794         } else if (pkt->isFlush()) {
796         } else if (pkt->req->isRelease() || pkt->req->isAcquire()) {
806                 if (pkt->req->hasContextId()) {
807                     wf_id = pkt->req->contextId();
809                 insertKernel(wf_id, pkt);
830     RequestStatus status = getRequestStatus(pkt, primary_type);
834     Addr line_addr = makeLineAddress(pkt->getAddr());
852     } else if (pkt->req->isLockedRMW() ||
853                reqCoalescer[line_addr][0].pkt->req->isLockedRMW()) {
856     } else if (pkt->req->hasContextId() && pkt->req->isRelease() &&
857                pkt->req->contextId() !=
858                reqCoalescer[line_addr][0].pkt->req->contextId()) {
864     reqCoalescer[line_addr].emplace_back(pkt, primary_type, secondary_type);
872 GPUCoalescer::issueRequest(PacketPtr pkt, RubyRequestType secondary_type)
876     if (pkt != NULL && pkt->req->hasContextId()) {
877         proc_id = pkt->req->contextId();
882     if (pkt->req->hasPC()) {
883         pc = pkt->req->getPC();
888     // which is pkt->req->isStack()
893     HSASegment accessSegment = reqSegmentToHSASegment(pkt->req);
894     HSAScope accessScope = reqScopeToHSAScope(pkt->req);
896     Addr line_addr = makeLineAddress(pkt->getAddr());
908         PacketPtr tmpPkt = reqCoalescer[line_addr][i].pkt;
924     if (pkt->isAtomicOp()) {
925         msg = std::make_shared<RubyRequest>(clockEdge(), pkt->getAddr(),
926                               pkt->getPtr<uint8_t>(),
927                               pkt->getSize(), pc, secondary_type,
928                               RubyAccessMode_Supervisor, pkt,
934         msg = std::make_shared<RubyRequest>(clockEdge(), pkt->getAddr(),
935                               pkt->getPtr<uint8_t>(),
936                               pkt->getSize(), pc, secondary_type,
937                               RubyAccessMode_Supervisor, pkt,
1010         PacketPtr pkt = info.pkt;
1012                 i, pkt->req->getPaddr());
1015         bool found = insertRequest(pkt, info.primaryType);
1023         issueRequest(pkt, info.secondaryType);
1078     PacketPtr pkt = srequest->pkt;
1079     Addr request_address = pkt->getAddr();
1080     Addr request_line_address = makeLineAddress(pkt->getAddr());
1085         PacketPtr pkt = reqCoalescer[request_line_address][i].pkt;
1088         request_address = (pkt->getAddr());
1090         if (pkt->getPtr<uint8_t>() &&
1093             pkt->setData(
1094                 data.getData(getOffset(request_address), pkt->getSize()));
1109                 safe_cast<RubyPort::SenderState*>(pkt->senderState);
1115         mylist.push_back(pkt);
1176     return request->pkt;
1254              printAddress(srequest->pkt->getAddr()), total_lat);