add restore memtrace

configs/common/Options.py

@@ -147,6 +147,8 @@ def addNoISAOptions(parser, configure_xiangshan=False):
     parser.add_argument("--l1-to-l2-pf-hint", action="store_true")
     parser.add_argument("--l2-to-l3-pf-hint", action="store_true")
 
+    parser.add_argument("--memtrace_path", type=str, default=None)  # Memtrace file path for restoring the microarchitectural state in L3 Cache
+
     parser.add_argument("--num-dirs", type=int, default=1)
     parser.add_argument("--num-l2caches", type=int, default=1)
     parser.add_argument("--num-l3caches", type=int, default=1)

configs/common/Simulation.py

@@ -821,7 +821,8 @@ def run_vanilla(options, root, testsys, cpu_class):
 
     checkpoint_dir = None
     root.apply_config(options.param)
-    m5.instantiate(checkpoint_dir)
+    # add path for generic_rv_cpt and memtrace_path
+    m5.instantiate(pmem_file_path=options.generic_rv_cpt,mem_trace_file=options.memtrace_path,ckpt_dir=checkpoint_dir)
 
     # Handle the max tick settings now that tick frequency was resolved
     # during system instantiation

configs/common/xiangshan.py

@@ -227,6 +227,9 @@ def config_xiangshan_inputs(args: argparse.Namespace, sys):
             sys.workload.raw_bootloader = True
         else:
             sys.gcpt_restorer_file = gcpt_restorer
+    if args.memtrace_path is not None:
+        sys.restore_from_memtrace = True
+        sys.memtrace_file = args.memtrace_path
     # enable h checkpoint
     if args.enable_h_gcpt:
         sys.enable_h_gcpt = True

src/mem/cache/cache_blk.hh

@@ -498,6 +498,16 @@ class CacheBlk : public TaggedEntry
         }
     }
 
+    // Public versions of some protected setters for use in restore L3 microarchitectural state
+    /** Set the task id value. */
+    void setTaskId_pub(const uint32_t task_id) { _taskId = task_id; }
+
+    /** Set the source requestor id. */
+    void setSrcRequestorId_pub(const uint32_t id) { _srcRequestorId = id; }
+
+    /** Set the current tick as this block's insertion tick. */
+    void setTickInserted_pub() { _tickInserted = curTick(); }
+
     /** Set the XS metadata. */
     void setXsMetadata(const Request::XsMetadata &xs_meta)
     {

src/mem/cache/replacement_policies/base.hh

@@ -95,6 +95,8 @@ class Base : public SimObject
     virtual void reset(const std::shared_ptr<ReplacementData>&
         replacement_data) const = 0;
 
+    virtual void reset4memtrace(const std::shared_ptr<ReplacementData>&
+    replacement_data,int priority) const = 0;
     /**
      * Find replacement victim among candidates.
      *

src/mem/cache/replacement_policies/bip_rp.hh

@@ -76,6 +76,9 @@ class BIP : public LRU
      */
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {     
+    }     
 };
 
 } // namespace replacement_policy

src/mem/cache/replacement_policies/brrip_rp.hh

@@ -143,6 +143,9 @@ class BRRIP : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {     
+    }   
     /**
      * Find replacement victim using rrpv.
      *

src/mem/cache/replacement_policies/dueling_rp.hh

@@ -115,6 +115,9 @@ class Dueling : public Base
         const PacketPtr pkt) override;
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {   
+    }   
     ReplaceableEntry* getVictim(const ReplacementCandidates& candidates) const
                                                                      override;
     std::shared_ptr<ReplacementData> instantiateEntry() override;

src/mem/cache/replacement_policies/fifo_rp.hh

@@ -95,6 +95,9 @@ class FIFO : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {    
+    }   
     /**
      * Find replacement victim using insertion timestamps.
      *

src/mem/cache/replacement_policies/lfu_rp.hh

@@ -95,6 +95,9 @@ class LFU : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }   
     /**
      * Find replacement victim using reference frequency.
      *

src/mem/cache/replacement_policies/lru_rp.cc

@@ -70,6 +70,15 @@ LRU::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
         replacement_data)->lastTouchTick = curTick();
 }
 
+void
+LRU::reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const
+{
+    // Set last touch timestamp
+    // Here we use priority to set lastTouchTick, the lower the priority, the older the lastTouchTick
+    std::static_pointer_cast<LRUReplData>(
+        replacement_data)->lastTouchTick = curTick() - priority;
+}
+
 ReplaceableEntry*
 LRU::getVictim(const ReplacementCandidates& candidates) const
 {

src/mem/cache/replacement_policies/lru_rp.hh

@@ -93,6 +93,8 @@ class LRU : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override;
+
     /**
      * Find replacement victim using LRU timestamps.
      *

src/mem/cache/replacement_policies/mru_rp.hh

@@ -95,6 +95,9 @@ class MRU : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }
     /**
      * Find replacement victim using access timestamps.
      *

src/mem/cache/replacement_policies/random_rp.hh

@@ -96,6 +96,9 @@ class Random : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }
     /**
      * Find replacement victim at random.
      *

src/mem/cache/replacement_policies/second_chance_rp.hh

@@ -110,6 +110,9 @@ class SecondChance : public FIFO
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }
     /**
      * Find replacement victim using insertion timestamps and second chance
      * bit.

src/mem/cache/replacement_policies/ship_rp.hh

@@ -153,6 +153,9 @@ class SHiP : public BRRIP
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
         override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }
     /**
      * Instantiate a replacement data entry.
      *

src/mem/cache/replacement_policies/tree_plru_rp.hh

@@ -187,6 +187,9 @@ class TreePLRU : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }
     /**
      * Find replacement victim using TreePLRU bits. It is assumed that all
      * candidates share the same replacement data tree.

src/mem/cache/replacement_policies/xs_drrip_rp.hh

@@ -204,6 +204,9 @@ class XSDRRIP : public Base
     void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
                                                                      override;
 
+    void reset4memtrace(const std::shared_ptr<ReplacementData>& replacement_data,int priority) const override
+    {
+    }
     /**
      * Find victim for replacement
      */

src/mem/cache/tags/base.cc

@@ -55,6 +55,16 @@
 #include "sim/sim_exit.hh"
 #include "sim/system.hh"
 
+#include <iostream>
+#include <zlib.h>
+#include <cstdio>
+#include <fstream>
+#include <vector>
+#include <stdexcept>
+#include <cstdint>
+#include <iomanip>
+#include "sim/root.hh"
+
 namespace gem5
 {
 
@@ -311,4 +321,186 @@ BaseTags::BaseTagStats::preDumpStats()
     tags.computeStats();
 }
 
+
+// restore L3 cache microarchitecture states based on memtrace
+void
+BaseTags::warmupState(const std::string &pmem_file,const std::string &memtrace_file)
+{
+     std::ifstream file(memtrace_file);         // the file contains the microarchitecture states from memtrace
+     if(!file.is_open())
+     {
+        std::cout << "File open failed:" << memtrace_file << std::endl;
+     };
+     std::string line;
+    std::string taskid;
+    std::string requestorid;
+    std::string rank;
+     int line_max = this->size / this->blkSize; //compute the number of cache lines
+     volatile int offset_num=0;
+     int num = this->blkMask;
+     while(num)                                 //compute tag+set bits
+     {
+        offset_num += num & 1;
+        num >>= 1;
+     }
+
+     int total_num =64;                            //compute set bits
+
+     int assoc = this->indexingPolicy->getAssoc();
+
+     num = size/assoc;
+     num = num/blkSize;
+     volatile int set_num=0;
+     while(num)
+     {
+        num >>= 1;
+        set_num++;
+     }
+     set_num--;
+     volatile int tag_num= total_num-set_num-offset_num;
+
+     std::vector<char> decompressed_data = decompress_gz_to_memory(pmem_file);
+    for(int line_num=0;line_num<line_max;line_num++)
+    {
+        std::getline(file,line);
+        std::getline(file,taskid);
+        std::getline(file,requestorid);
+        std::getline(file,rank);
+        int memtrace_priority = std::stoi(rank);
+        char myvalid = line[0];
+        char myhit = line[1];
+        if( myhit == '1')
+        {
+        std::string mytag = line.substr(3,tag_num); // paddr
+        int myset = line_num / assoc; // paddr
+        std::bitset<32> setbin(myset);
+        std::string myset_str = setbin.to_string();
+
+        myset_str=myset_str.substr(myset_str.size()-set_num,set_num);
+        std::string myaddr = mytag+myset_str;
+        myaddr.append(offset_num,'0');//paddr
+
+        const Addr p_addr = std::stoull(myaddr, nullptr, 2);
+        const Addr h_addr = p_addr - 0x100000000 + 0x80000000;// host
+        Addr tag = std::stoull(mytag, nullptr, 2);
+        uint32_t set = indexingPolicy->myextractSet(p_addr);
+        const bool is_secure = false;
+
+    std::size_t blk_size_bits = blkSize*8;
+
+
+    // Find replacement victim
+    std::vector<CacheBlk*> evict_blks;
+    CacheBlk *victim = this->findVictim(p_addr, is_secure, blk_size_bits,
+                                            evict_blks);
+    this->updateRp(victim,memtrace_priority);//replacement policy state update
+    victim->insert(tag, is_secure);
+    victim->setSrcRequestorId_pub(static_cast<uint16_t>(std::stoul(requestorid)));
+    victim->setTaskId_pub(static_cast<uint32_t>(std::stoul(taskid)));
+    victim->setTickInserted_pub();
+    victim->setCoherenceBits(CacheBlk::WritableBit);
+    victim->setCoherenceBits(CacheBlk::ReadableBit);
+
+    Addr offset = p_addr & Addr (blkSize - 1);
+    unsigned size = this->blkSize;
+    char result_buffer[size + 1];
+    size_t bytes_read = query_in_memory(decompressed_data, h_addr, result_buffer, size);
+    std::memcpy(victim->data + offset, result_buffer, size);
+    victim->setWhenReady(curTick());
+        }
+        else if(myvalid != '1')
+        {
+            break;
+        }
+    }
+    file.close();
+}
+
+
+std::vector<char>
+BaseTags::decompress_gz_to_memory(const std::string& gz_path) {
+    std::vector<char> decompressed_data;
+    const size_t CHUNK_SIZE = 32 * 1024;
+    std::vector<char> in_buffer(CHUNK_SIZE);
+    std::vector<char> out_buffer(CHUNK_SIZE * 2);
+    std::ifstream gz_file(gz_path, std::ios_base::binary);
+    if (!gz_file.is_open()) {
+        throw std::runtime_error("File open failed: " + gz_path);
+    }
+    z_stream strm;
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    int ret = inflateInit2(&strm, MAX_WBITS | 16);
+    if (ret != Z_OK) {
+        throw std::runtime_error("inflateInit2 falied: " + std::to_string(ret));
+    }
+
+    while (true) {
+        gz_file.read(in_buffer.data(), in_buffer.size());
+        std::streamsize bytes_read = gz_file.gcount();
+
+        strm.avail_in = static_cast<uInt>(bytes_read);
+        strm.next_in = reinterpret_cast<Bytef*>(in_buffer.data());
+
+        if (strm.avail_in == 0 && strm.avail_out == 0) {
+            break;
+        }
+
+        do {
+            strm.avail_out = static_cast<uInt>(out_buffer.size());
+            strm.next_out = reinterpret_cast<Bytef*>(out_buffer.data());
+
+            ret = inflate(&strm, Z_NO_FLUSH);
+
+            if (ret == Z_STREAM_ERROR) {
+                inflateEnd(&strm);
+                gz_file.close();
+                throw std::runtime_error("inflate failed: " + std::to_string(ret));
+            }
+
+            size_t bytes_decompressed = out_buffer.size() - strm.avail_out;
+            if (bytes_decompressed > 0) {
+                decompressed_data.insert(decompressed_data.end(),
+                                         out_buffer.begin(),
+                                         out_buffer.begin() + bytes_decompressed);
+            }
+
+        } while (strm.avail_out == 0);
+
+        if (bytes_read == 0) {
+            break;
+        }
+    }
+
+    if (ret != Z_STREAM_END) {
+         inflateEnd(&strm);
+         gz_file.close();
+         throw std::runtime_error("Decompression did not complete normally, the file may be corrupted. zlib return code: " + std::to_string(ret));
+    }
+
+    inflateEnd(&strm);
+    gz_file.close();
+    return decompressed_data;
+}
+size_t
+BaseTags::query_in_memory(const std::vector<char>& data,
+                       uint64_t target_address,
+                       char* result,
+                       size_t max_result_length) {
+    if (max_result_length == 0 || result == nullptr) {
+        return 0;
+    }
+
+    if (target_address >= data.size()) {
+        throw std::out_of_range("The destination address 0x "+ std::to_string(target_address) + " is out of the unzipped data range.");
+    }
+
+    size_t bytes_to_copy = std::min(max_result_length, data.size() - static_cast<size_t>(target_address));
+
+    std::memcpy(result, data.data() + target_address, bytes_to_copy);
+
+    return bytes_to_copy;
+}
+
 } // namespace gem5