Memory: Rename LOCKED for load locked store conditional to LLSC.

diff --git a/src/arch/alpha/isa/decoder.isa b/src/arch/alpha/isa/decoder.isa
index 0b2a31410968d437e1a8eabf99219dc868a1b496..278ce31e86445ce238c19de3fc29950fdbf9b418 100644 (file)
--- a/src/arch/alpha/isa/decoder.isa
+++ b/src/arch/alpha/isa/decoder.isa
@@ -45,8 +45,8 @@ decode OPCODE default Unknown::unknown() {
         0x0c: ldwu({{ Ra.uq = Mem.uw; }});
         0x0b: ldq_u({{ Ra = Mem.uq; }}, ea_code = {{ EA = (Rb + disp) & ~7; }});
         0x23: ldt({{ Fa = Mem.df; }});
-        0x2a: ldl_l({{ Ra.sl = Mem.sl; }}, mem_flags = LOCKED);
-        0x2b: ldq_l({{ Ra.uq = Mem.uq; }}, mem_flags = LOCKED);
+        0x2a: ldl_l({{ Ra.sl = Mem.sl; }}, mem_flags = LLSC);
+        0x2b: ldq_l({{ Ra.uq = Mem.uq; }}, mem_flags = LLSC);
 #ifdef USE_COPY
         0x20: MiscPrefetch::copy_load({{ EA = Ra; }},
                                       {{ fault = xc->copySrcTranslate(EA); }},
@@ -87,7 +87,7 @@ decode OPCODE default Unknown::unknown() {
                         if (tmp == 1) {
                             xc->setStCondFailures(0);
                         }
-                    }}, mem_flags = LOCKED, inst_flags = IsStoreConditional);
+                    }}, mem_flags = LLSC, inst_flags = IsStoreConditional);
         0x2f: stq_c({{ Mem.uq = Ra; }},
                     {{
                         uint64_t tmp = write_result;
@@ -105,7 +105,7 @@ decode OPCODE default Unknown::unknown() {
                             // only.
                             xc->setStCondFailures(0);
                         }
-                    }}, mem_flags = LOCKED, inst_flags = IsStoreConditional);
+                    }}, mem_flags = LLSC, inst_flags = IsStoreConditional);
     }
 
     format IntegerOperate {

diff --git a/src/arch/alpha/isa/pal.isa b/src/arch/alpha/isa/pal.isa
index 3d3b816007bacf96d042b5b533aca4c4313921ee..0931c1aecd67822eb425dea9cda4caa6296ab120 100644 (file)
--- a/src/arch/alpha/isa/pal.isa
+++ b/src/arch/alpha/isa/pal.isa
@@ -178,7 +178,7 @@ output decoder {{
         if (HW_LDST_PHYS) memAccessFlags.set(Request::PHYSICAL);
         if (HW_LDST_ALT)  memAccessFlags.set(Request::ALTMODE);
         if (HW_LDST_VPTE) memAccessFlags.set(Request::VPTE);
-        if (HW_LDST_LOCK) memAccessFlags.set(Request::LOCKED);
+        if (HW_LDST_LOCK) memAccessFlags.set(Request::LLSC);
     }
 
     std::string

diff --git a/src/arch/mips/isa/decoder.isa b/src/arch/mips/isa/decoder.isa
index 68a63a45842cc13eb2fc519c8b1b8355e729200b..a463093ecdc9beb981385509738e3c592964505c 100644 (file)
--- a/src/arch/mips/isa/decoder.isa
+++ b/src/arch/mips/isa/decoder.isa
@@ -2089,7 +2089,7 @@ decode OPCODE_HI default Unknown::unknown() {
 
     0x6: decode OPCODE_LO {
         format LoadMemory {
-            0x0: ll({{ Rt.uw = Mem.uw; }}, mem_flags=LOCKED);
+            0x0: ll({{ Rt.uw = Mem.uw; }}, mem_flags=LLSC);
             0x1: lwc1({{ Ft.uw = Mem.uw; }});
             0x5: ldc1({{ Ft.ud = Mem.ud; }});
         }
@@ -2103,7 +2103,7 @@ decode OPCODE_HI default Unknown::unknown() {
         0x0: StoreCond::sc({{ Mem.uw = Rt.uw;}},
                            {{ uint64_t tmp = write_result;
                               Rt.uw = (tmp == 0 || tmp == 1) ? tmp : Rt.uw;
-                           }}, mem_flags=LOCKED, inst_flags = IsStoreConditional);
+                           }}, mem_flags=LLSC, inst_flags = IsStoreConditional);
 
         format StoreMemory {
           0x1: swc1({{ Mem.uw = Ft.uw;}});

diff --git a/src/cpu/checker/cpu.cc b/src/cpu/checker/cpu.cc
index 1c36ad22d5309f59df55bb3f70e8bcf5bcb001dd..4305f7ab0aeb8d10a6c57bfd578de478a19d0992 100644 (file)
--- a/src/cpu/checker/cpu.cc
+++ b/src/cpu/checker/cpu.cc
@@ -240,8 +240,8 @@ CheckerCPU::write(T data, Addr addr, unsigned flags, uint64_t *res)
     // verify this data.
     if (unverifiedReq &&
         !(unverifiedReq->isUncacheable()) &&
-        (!(unverifiedReq->isLocked()) ||
-         ((unverifiedReq->isLocked()) &&
+        (!(unverifiedReq->isLlsc()) ||
+         ((unverifiedReq->isLlsc()) &&
           unverifiedReq->getExtraData() == 1))) {
         T inst_data;
 /*

diff --git a/src/cpu/inorder/resources/cache_unit.cc b/src/cpu/inorder/resources/cache_unit.cc
index 57bcb10ef6be648a011c295894ce5fc3f6f0b8fd..ceaaf35326601f181b39f6cc942ddb0e4bf0f176 100644 (file)
--- a/src/cpu/inorder/resources/cache_unit.cc
+++ b/src/cpu/inorder/resources/cache_unit.cc
@@ -355,7 +355,7 @@ CacheUnit::doDataAccess(DynInstPtr inst)
 
     Request *memReq = cache_req->dataPkt->req;
 
-    if (cache_req->dataPkt->isWrite() && memReq->isLocked()) {
+    if (cache_req->dataPkt->isWrite() && memReq->isLlsc()) {
         assert(cache_req->inst->isStoreConditional());
         DPRINTF(InOrderCachePort, "Evaluating Store Conditional access\n");
         do_access = TheISA::handleLockedWrite(cpu, memReq);
@@ -395,7 +395,7 @@ CacheUnit::doDataAccess(DynInstPtr inst)
             cacheStatus = cacheWaitResponse;
             cacheBlocked = false;
         }
-    } else if (!do_access && memReq->isLocked()){
+    } else if (!do_access && memReq->isLlsc()){
         // Store-Conditional instructions complete even if they "failed"
         assert(cache_req->inst->isStoreConditional());
         cache_req->setCompleted(true);
@@ -471,7 +471,7 @@ CacheUnit::processCacheCompletion(PacketPtr pkt)
             if (inst->isLoad()) {
                 assert(cache_pkt->isRead());
 
-                if (cache_pkt->req->isLocked()) {
+                if (cache_pkt->req->isLlsc()) {
                     DPRINTF(InOrderCachePort,
                             "[tid:%u]: Handling Load-Linked for [sn:%u]\n",
                             tid, inst->seqNum);

diff --git a/src/cpu/o3/lsq_unit.hh b/src/cpu/o3/lsq_unit.hh
index 5323e3a472319f1a1a19b09dc418364a165bff5d..9f0f38f0694a07ab6424b9bfb54fce67fe2aff5b 100644 (file)
--- a/src/cpu/o3/lsq_unit.hh
+++ b/src/cpu/o3/lsq_unit.hh
@@ -514,7 +514,7 @@ LSQUnit<Impl>::read(Request *req, T &data, int load_idx)
             "storeHead: %i addr: %#x\n",
             load_idx, store_idx, storeHead, req->getPaddr());
 
-    if (req->isLocked()) {
+    if (req->isLlsc()) {
         // Disable recording the result temporarily.  Writing to misc
         // regs normally updates the result, but this is not the
         // desired behavior when handling store conditionals.
@@ -647,7 +647,7 @@ LSQUnit<Impl>::read(Request *req, T &data, int load_idx)
     if (!lsq->cacheBlocked()) {
         PacketPtr data_pkt =
             new Packet(req,
-                       (req->isLocked() ?
+                       (req->isLlsc() ?
                         MemCmd::LoadLockedReq : MemCmd::ReadReq),
                        Packet::Broadcast);
         data_pkt->dataStatic(load_inst->memData);

diff --git a/src/cpu/o3/lsq_unit_impl.hh b/src/cpu/o3/lsq_unit_impl.hh
index 85662d4963e7a762a2e03698197072b043244702..f5753a4eff996357460745ac5740c3c230efa64f 100644 (file)
--- a/src/cpu/o3/lsq_unit_impl.hh
+++ b/src/cpu/o3/lsq_unit_impl.hh
@@ -652,7 +652,7 @@ LSQUnit<Impl>::writebackStores()
 
         MemCmd command =
             req->isSwap() ? MemCmd::SwapReq :
-            (req->isLocked() ? MemCmd::StoreCondReq : MemCmd::WriteReq);
+            (req->isLlsc() ? MemCmd::StoreCondReq : MemCmd::WriteReq);
         PacketPtr data_pkt = new Packet(req, command,
                                         Packet::Broadcast);
         data_pkt->dataStatic(inst->memData);

diff --git a/src/cpu/ozone/back_end_impl.hh b/src/cpu/ozone/back_end_impl.hh
index 415407c528e6425e65016f988522d50bd88a4774..ef3b0f1822a5cff144e1f10c1e8aa322737b9e4d 100644 (file)
--- a/src/cpu/ozone/back_end_impl.hh
+++ b/src/cpu/ozone/back_end_impl.hh
@@ -1256,7 +1256,7 @@ BackEnd<Impl>::executeInsts()
 
 //                ++iewExecStoreInsts;
 
-                if (!(inst->req->isLocked())) {
+                if (!(inst->req->isLlsc())) {
                     inst->setExecuted();
 
                     instToCommit(inst);

diff --git a/src/cpu/ozone/inorder_back_end.hh b/src/cpu/ozone/inorder_back_end.hh
index e930144be8dfa6d1388309520d155865f3e6613c..b30b37a223f670e568862cdf14620efb39bdbf70 100644 (file)
--- a/src/cpu/ozone/inorder_back_end.hh
+++ b/src/cpu/ozone/inorder_back_end.hh
@@ -381,7 +381,7 @@ InorderBackEnd<Impl>::write(MemReqPtr &req, T &data, int store_idx)
         }
     }
 /*
-    if (req->isLocked()) {
+    if (req->isLlsc()) {
         if (req->isUncacheable()) {
             // Don't update result register (see stq_c in isa_desc)
             req->result = 2;

diff --git a/src/cpu/ozone/lsq_unit_impl.hh b/src/cpu/ozone/lsq_unit_impl.hh
index c24410520b06bdf36c777b600ccb020620e23aaa..7e7bbdb0112f98aae5d2046dbb4622a9e5cfb3b2 100644 (file)
--- a/src/cpu/ozone/lsq_unit_impl.hh
+++ b/src/cpu/ozone/lsq_unit_impl.hh
@@ -577,7 +577,7 @@ OzoneLSQ<Impl>::writebackStores()
             MemAccessResult result = dcacheInterface->access(req);
 
             //@todo temp fix for LL/SC (works fine for 1 CPU)
-            if (req->isLocked()) {
+            if (req->isLlsc()) {
                 req->result=1;
                 panic("LL/SC! oh no no support!!!");
             }
@@ -596,7 +596,7 @@ OzoneLSQ<Impl>::writebackStores()
                 Event *wb = NULL;
 /*
                 typename IEW::LdWritebackEvent *wb = NULL;
-                if (req->isLocked()) {
+                if (req->isLlsc()) {
                     // Stx_C does not generate a system port transaction.
                     req->result=0;
                     wb = new typename IEW::LdWritebackEvent(storeQueue[storeWBIdx].inst,
@@ -630,7 +630,7 @@ OzoneLSQ<Impl>::writebackStores()
 //                DPRINTF(Activity, "Active st accessing mem hit [sn:%lli]\n",
 //                        storeQueue[storeWBIdx].inst->seqNum);
 
-                if (req->isLocked()) {
+                if (req->isLlsc()) {
                     // Stx_C does not generate a system port transaction.
                     req->result=1;
                     typename BackEnd::LdWritebackEvent *wb =

diff --git a/src/cpu/ozone/lw_lsq.hh b/src/cpu/ozone/lw_lsq.hh
index 4f8101bc015b992025a0fa68fc69d1ab02ef01a7..3ad8d1d642d7e8a8f543be965e7cac61a9d89295 100644 (file)
--- a/src/cpu/ozone/lw_lsq.hh
+++ b/src/cpu/ozone/lw_lsq.hh
@@ -635,7 +635,7 @@ OzoneLWLSQ<Impl>::read(RequestPtr req, T &data, int load_idx)
 
     PacketPtr data_pkt =
         new Packet(req,
-                   (req->isLocked() ?
+                   (req->isLlsc() ?
                     MemCmd::LoadLockedReq : Packet::ReadReq),
                    Packet::Broadcast);
     data_pkt->dataStatic(inst->memData);
@@ -662,7 +662,7 @@ OzoneLWLSQ<Impl>::read(RequestPtr req, T &data, int load_idx)
         return NoFault;
     }
 
-    if (req->isLocked()) {
+    if (req->isLlsc()) {
         cpu->lockFlag = true;
     }
 

diff --git a/src/cpu/ozone/lw_lsq_impl.hh b/src/cpu/ozone/lw_lsq_impl.hh
index 00e52e039a5d455a19d1824e50c777edf2624fdc..3943dab2d922793ce1d57152cdf875e386532cdb 100644 (file)
--- a/src/cpu/ozone/lw_lsq_impl.hh
+++ b/src/cpu/ozone/lw_lsq_impl.hh
@@ -589,7 +589,7 @@ OzoneLWLSQ<Impl>::writebackStores()
 
         MemCmd command =
             req->isSwap() ? MemCmd::SwapReq :
-            (req->isLocked() ? MemCmd::WriteReq : MemCmd::StoreCondReq);
+            (req->isLlsc() ? MemCmd::WriteReq : MemCmd::StoreCondReq);
         PacketPtr data_pkt = new Packet(req, command, Packet::Broadcast);
         data_pkt->dataStatic(inst->memData);
 
@@ -606,7 +606,7 @@ OzoneLWLSQ<Impl>::writebackStores()
                 inst->seqNum);
 
         // @todo: Remove this SC hack once the memory system handles it.
-        if (req->isLocked()) {
+        if (req->isLlsc()) {
             if (req->isUncacheable()) {
                 req->setExtraData(2);
             } else {
@@ -664,7 +664,7 @@ OzoneLWLSQ<Impl>::writebackStores()
             if (result != MA_HIT && dcacheInterface->doEvents()) {
                 store_event->miss = true;
                 typename BackEnd::LdWritebackEvent *wb = NULL;
-                if (req->isLocked()) {
+                if (req->isLlsc()) {
                     wb = new typename BackEnd::LdWritebackEvent(inst,
                                                             be);
                     store_event->wbEvent = wb;
@@ -691,7 +691,7 @@ OzoneLWLSQ<Impl>::writebackStores()
 //                DPRINTF(Activity, "Active st accessing mem hit [sn:%lli]\n",
 //                        inst->seqNum);
 
-                if (req->isLocked()) {
+                if (req->isLlsc()) {
                     // Stx_C does not generate a system port
                     // transaction in the 21264, but that might be
                     // hard to accomplish in this model.

diff --git a/src/cpu/simple/atomic.cc b/src/cpu/simple/atomic.cc
index 3ce0ba172344cb2051d2dd24f0ead25a0c8ab5a1..045b0160f68f7a474de0225d1806ebc8bbd599be 100644 (file)
--- a/src/cpu/simple/atomic.cc
+++ b/src/cpu/simple/atomic.cc
@@ -322,7 +322,7 @@ AtomicSimpleCPU::read(Addr addr, T &data, unsigned flags)
         // Now do the access.
         if (fault == NoFault) {
             Packet pkt = Packet(req,
-                    req->isLocked() ? MemCmd::LoadLockedReq : MemCmd::ReadReq,
+                    req->isLlsc() ? MemCmd::LoadLockedReq : MemCmd::ReadReq,
                     Packet::Broadcast);
             pkt.dataStatic(dataPtr);
 
@@ -338,7 +338,7 @@ AtomicSimpleCPU::read(Addr addr, T &data, unsigned flags)
 
             assert(!pkt.isError());
 
-            if (req->isLocked()) {
+            if (req->isLlsc()) {
                 TheISA::handleLockedRead(thread, req);
             }
         }
@@ -462,7 +462,7 @@ AtomicSimpleCPU::write(T data, Addr addr, unsigned flags, uint64_t *res)
             MemCmd cmd = MemCmd::WriteReq; // default
             bool do_access = true;  // flag to suppress cache access
 
-            if (req->isLocked()) {
+            if (req->isLlsc()) {
                 cmd = MemCmd::StoreCondReq;
                 do_access = TheISA::handleLockedWrite(thread, req);
             } else if (req->isSwap()) {

diff --git a/src/cpu/simple/timing.cc b/src/cpu/simple/timing.cc
index 64c4108a7c7084659eb48c04dc5e4b74adcbfa46..905acb6d46c1265173ce8db31dbc11476a0c345c 100644 (file)
--- a/src/cpu/simple/timing.cc
+++ b/src/cpu/simple/timing.cc
@@ -290,7 +290,7 @@ TimingSimpleCPU::sendData(Fault fault, RequestPtr req,
     } else {
         bool do_access = true;  // flag to suppress cache access
 
-        if (req->isLocked()) {
+        if (req->isLlsc()) {
             do_access = TheISA::handleLockedWrite(thread, req);
         } else if (req->isCondSwap()) {
             assert(res);
@@ -384,11 +384,11 @@ TimingSimpleCPU::buildPacket(PacketPtr &pkt, RequestPtr req, bool read)
     MemCmd cmd;
     if (read) {
         cmd = MemCmd::ReadReq;
-        if (req->isLocked())
+        if (req->isLlsc())
             cmd = MemCmd::LoadLockedReq;
     } else {
         cmd = MemCmd::WriteReq;
-        if (req->isLocked()) {
+        if (req->isLlsc()) {
             cmd = MemCmd::StoreCondReq;
         } else if (req->isSwap()) {
             cmd = MemCmd::SwapReq;
@@ -452,7 +452,7 @@ TimingSimpleCPU::read(Addr addr, T &data, unsigned flags)
     _status = DTBWaitResponse;
     if (split_addr > addr) {
         RequestPtr req1, req2;
-        assert(!req->isLocked() && !req->isSwap());
+        assert(!req->isLlsc() && !req->isSwap());
         req->splitOnVaddr(split_addr, req1, req2);
 
         typedef SplitDataTranslation::WholeTranslationState WholeState;
@@ -571,7 +571,7 @@ TimingSimpleCPU::write(T data, Addr addr, unsigned flags, uint64_t *res)
     _status = DTBWaitResponse;
     if (split_addr > addr) {
         RequestPtr req1, req2;
-        assert(!req->isLocked() && !req->isSwap());
+        assert(!req->isLlsc() && !req->isSwap());
         req->splitOnVaddr(split_addr, req1, req2);
 
         typedef SplitDataTranslation::WholeTranslationState WholeState;
@@ -904,7 +904,7 @@ TimingSimpleCPU::completeDataAccess(PacketPtr pkt)
 
     // the locked flag may be cleared on the response packet, so check
     // pkt->req and not pkt to see if it was a load-locked
-    if (pkt->isRead() && pkt->req->isLocked()) {
+    if (pkt->isRead() && pkt->req->isLlsc()) {
         TheISA::handleLockedRead(thread, pkt->req);
     }
 

diff --git a/src/mem/cache/blk.hh b/src/mem/cache/blk.hh
index fe65672d66202621c513846f07d3b4abfe6218c2..acb117f6c7bce3e27179a8023a5ce19edba7fe8b 100644 (file)
--- a/src/mem/cache/blk.hh
+++ b/src/mem/cache/blk.hh
@@ -218,7 +218,7 @@ class CacheBlk
      */
     void trackLoadLocked(PacketPtr pkt)
     {
-        assert(pkt->isLocked());
+        assert(pkt->isLlsc());
         lockList.push_front(Lock(pkt->req));
     }
 
@@ -236,7 +236,7 @@ class CacheBlk
     bool checkWrite(PacketPtr pkt)
     {
         Request *req = pkt->req;
-        if (pkt->isLocked()) {
+        if (pkt->isLlsc()) {
             // it's a store conditional... have to check for matching
             // load locked.
             bool success = false;

diff --git a/src/mem/cache/cache_impl.hh b/src/mem/cache/cache_impl.hh
index a78fd363792c510d67707695eb01d4cf9dec966d..f98d6ac3465a3b05cc0529d65b31f570ffda4a13 100644 (file)
--- a/src/mem/cache/cache_impl.hh
+++ b/src/mem/cache/cache_impl.hh
@@ -180,7 +180,7 @@ Cache<TagStore>::satisfyCpuSideRequest(PacketPtr pkt, BlkType *blk)
             pkt->writeDataToBlock(blk->data, blkSize);
         }
     } else if (pkt->isRead()) {
-        if (pkt->isLocked()) {
+        if (pkt->isLlsc()) {
             blk->trackLoadLocked(pkt);
         }
         pkt->setDataFromBlock(blk->data, blkSize);
@@ -317,7 +317,7 @@ Cache<TagStore>::access(PacketPtr pkt, BlkType *&blk,
 
     incMissCount(pkt);
 
-    if (blk == NULL && pkt->isLocked() && pkt->isWrite()) {
+    if (blk == NULL && pkt->isLlsc() && pkt->isWrite()) {
         // complete miss on store conditional... just give up now
         pkt->req->setExtraData(0);
         return true;

diff --git a/src/mem/packet.cc b/src/mem/packet.cc
index 38b8879e57e39579c7ea12d442eabd9550b4d90c..2f84e4414a78aab741b23200e935a2dcc18a842d 100644 (file)
--- a/src/mem/packet.cc
+++ b/src/mem/packet.cc
@@ -105,14 +105,14 @@ MemCmd::commandInfo[] =
             InvalidCmd, "ReadExResp" },
     /* LoadLockedReq: note that we use plain ReadResp as response, so that
      *                we can also use ReadRespWithInvalidate when needed */
-    { SET4(IsRead, IsLocked, IsRequest, NeedsResponse),
+    { SET4(IsRead, IsLlsc, IsRequest, NeedsResponse),
             ReadResp, "LoadLockedReq" },
     /* StoreCondReq */
-    { SET6(IsWrite, NeedsExclusive, IsLocked,
+    { SET6(IsWrite, NeedsExclusive, IsLlsc,
            IsRequest, NeedsResponse, HasData),
             StoreCondResp, "StoreCondReq" },
     /* StoreCondResp */
-    { SET4(IsWrite, NeedsExclusive, IsLocked, IsResponse),
+    { SET4(IsWrite, NeedsExclusive, IsLlsc, IsResponse),
             InvalidCmd, "StoreCondResp" },
     /* SwapReq -- for Swap ldstub type operations */
     { SET6(IsRead, IsWrite, NeedsExclusive, IsRequest, HasData, NeedsResponse),

diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index 41f599fa0701258cfd8bfecf33f8995726f7cd2c..965482c025217b9d8f14ed4e8e0a9509f2685799 100644 (file)
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -120,7 +120,7 @@ class MemCmd
         NeedsResponse,  //!< Requester needs response from target
         IsSWPrefetch,
         IsHWPrefetch,
-        IsLocked,       //!< Alpha/MIPS LL or SC access
+        IsLlsc,         //!< Alpha/MIPS LL or SC access
         HasData,        //!< There is an associated payload
         IsError,        //!< Error response
         IsPrint,        //!< Print state matching address (for debugging)
@@ -166,7 +166,7 @@ class MemCmd
     bool isInvalidate() const   { return testCmdAttrib(IsInvalidate); }
     bool hasData() const        { return testCmdAttrib(HasData); }
     bool isReadWrite() const    { return isRead() && isWrite(); }
-    bool isLocked() const       { return testCmdAttrib(IsLocked); }
+    bool isLlsc() const         { return testCmdAttrib(IsLlsc); }
     bool isError() const        { return testCmdAttrib(IsError); }
     bool isPrint() const        { return testCmdAttrib(IsPrint); }
 
@@ -401,7 +401,7 @@ class Packet : public FastAlloc, public Printable
     bool isInvalidate() const   { return cmd.isInvalidate(); }
     bool hasData() const        { return cmd.hasData(); }
     bool isReadWrite() const    { return cmd.isReadWrite(); }
-    bool isLocked() const       { return cmd.isLocked(); }
+    bool isLlsc() const         { return cmd.isLlsc(); }
     bool isError() const        { return cmd.isError(); }
     bool isPrint() const        { return cmd.isPrint(); }
 

diff --git a/src/mem/physical.cc b/src/mem/physical.cc
index 16ff3de6ddb49520dabe4e734950b662b891bc0c..86ecb506f5a7e4752366e7dfe57f1ae4b651be45 100644 (file)
--- a/src/mem/physical.cc
+++ b/src/mem/physical.cc
@@ -125,7 +125,7 @@ PhysicalMemory::calculateLatency(PacketPtr pkt)
 
 
 // Add load-locked to tracking list.  Should only be called if the
-// operation is a load and the LOCKED flag is set.
+// operation is a load and the LLSC flag is set.
 void
 PhysicalMemory::trackLoadLocked(PacketPtr pkt)
 {
@@ -162,12 +162,12 @@ PhysicalMemory::checkLockedAddrList(PacketPtr pkt)
 {
     Request *req = pkt->req;
     Addr paddr = LockedAddr::mask(req->getPaddr());
-    bool isLocked = pkt->isLocked();
+    bool isLlsc = pkt->isLlsc();
 
     // Initialize return value.  Non-conditional stores always
     // succeed.  Assume conditional stores will fail until proven
     // otherwise.
-    bool success = !isLocked;
+    bool success = !isLlsc;
 
     // Iterate over list.  Note that there could be multiple matching
     // records, as more than one context could have done a load locked
@@ -179,7 +179,7 @@ PhysicalMemory::checkLockedAddrList(PacketPtr pkt)
         if (i->addr == paddr) {
             // we have a matching address
 
-            if (isLocked && i->matchesContext(req)) {
+            if (isLlsc && i->matchesContext(req)) {
                 // it's a store conditional, and as far as the memory
                 // system can tell, the requesting context's lock is
                 // still valid.
@@ -199,7 +199,7 @@ PhysicalMemory::checkLockedAddrList(PacketPtr pkt)
         }
     }
 
-    if (isLocked) {
+    if (isLlsc) {
         req->setExtraData(success ? 1 : 0);
     }
 
@@ -284,7 +284,7 @@ PhysicalMemory::doAtomicAccess(PacketPtr pkt)
         TRACE_PACKET("Read/Write");
     } else if (pkt->isRead()) {
         assert(!pkt->isWrite());
-        if (pkt->isLocked()) {
+        if (pkt->isLlsc()) {
             trackLoadLocked(pkt);
         }
         if (pmemAddr)

diff --git a/src/mem/physical.hh b/src/mem/physical.hh
index d18138ecdfa5e64469436c170533a0080dd673b1..2a3bea7a5aacf51ef30e1523264c42dba6df72c5 100644 (file)
--- a/src/mem/physical.hh
+++ b/src/mem/physical.hh
@@ -129,11 +129,11 @@ class PhysicalMemory : public MemObject
         Request *req = pkt->req;
         if (lockedAddrList.empty()) {
             // no locked addrs: nothing to check, store_conditional fails
-            bool isLocked = pkt->isLocked();
-            if (isLocked) {
+            bool isLlsc = pkt->isLlsc();
+            if (isLlsc) {
                 req->setExtraData(0);
             }
-            return !isLocked; // only do write if not an sc
+            return !isLlsc; // only do write if not an sc
         } else {
             // iterate over list...
             return checkLockedAddrList(pkt);

diff --git a/src/mem/request.hh b/src/mem/request.hh
index ee62ce77162e4a9531717f003cf63a431756b08c..9e8208260775dba0f4c1d79436616c271529a513 100644 (file)
--- a/src/mem/request.hh
+++ b/src/mem/request.hh
@@ -62,7 +62,7 @@ class Request : public FastAlloc
     /** ASI information for this request if it exists. */
     static const FlagsType ASI_BITS                    = 0x000000FF;
     /** The request is a Load locked/store conditional. */
-    static const FlagsType LOCKED                      = 0x00000100;
+    static const FlagsType LLSC                        = 0x00000100;
     /** The virtual address is also the physical address. */
     static const FlagsType PHYSICAL                    = 0x00000200;
     /** The request is an ALPHA VPTE pal access (hw_ld). */
@@ -448,7 +448,7 @@ class Request : public FastAlloc
     /** Accessor Function to Check Cacheability. */
     bool isUncacheable() const { return flags.isSet(UNCACHEABLE); }
     bool isInstRead() const { return flags.isSet(INST_READ); }
-    bool isLocked() const { return flags.isSet(LOCKED); }
+    bool isLlsc() const { return flags.isSet(LLSC); }
     bool isSwap() const { return flags.isSet(MEM_SWAP|MEM_SWAP_COND); }
     bool isCondSwap() const { return flags.isSet(MEM_SWAP_COND); }