update frequency policy and fix rob

Author: vickiegpt

include/cxlcontroller.h

@@ -64,6 +64,94 @@ class CachingPolicy : public Policy {
     // paging related
 };
 
+struct LRUCacheEntry {
+    uint64_t key; // 缓存键（地址）
+    uint64_t value; // 缓存值
+    uint64_t timestamp; // 最后访问时间戳
+};
+
+// LRU缓存
+class LRUCache {
+    public:
+    int capacity; // 缓存容量
+    std::unordered_map<uint64_t, LRUCacheEntry> cache; // 缓存映射
+    std::list<uint64_t> lru_list; // LRU列表，最近使用的在前面
+    std::unordered_map<uint64_t, std::list<uint64_t>::iterator> lru_map; // 用于O(1)查找列表位置
+
+    explicit LRUCache(int size) : capacity(size) {}
+
+    // 获取缓存值，如果存在则更新访问顺序
+    std::optional<uint64_t> get(uint64_t key, uint64_t timestamp) {
+        auto it = cache.find(key);
+        if (it == cache.end()) {
+            return std::nullopt; // 缓存未命中
+        }
+
+        // 更新访问顺序
+        lru_list.erase(lru_map[key]);
+        lru_list.push_front(key);
+        lru_map[key] = lru_list.begin();
+
+        // 更新时间戳
+        it->second.timestamp = timestamp;
+
+        return it->second.value; // 返回缓存值
+    }
+
+    // 添加或更新缓存
+    void put(uint64_t key, uint64_t value, uint64_t timestamp) {
+        // 如果已存在，先移除旧位置
+        if (cache.find(key) != cache.end()) {
+            lru_list.erase(lru_map[key]);
+        }
+        // 如果缓存已满，移除最久未使用的项
+        else if (cache.size() >= capacity) {
+            uint64_t lru_key = lru_list.back();
+            lru_list.pop_back();
+            lru_map.erase(lru_key);
+            cache.erase(lru_key);
+        }
+
+        // 添加新项到最前面（最近使用）
+        lru_list.push_front(key);
+        lru_map[key] = lru_list.begin();
+        cache[key] = {key, value, timestamp};
+    }
+
+    // 获取缓存使用情况统计
+    std::tuple<int, int> get_stats() { return {cache.size(), capacity}; }
+
+    // 清除缓存
+    void clear() {
+        cache.clear();
+        lru_list.clear();
+        lru_map.clear();
+    }
+    // LRU缓存类中添加size()方法
+    size_t size() const {
+        return cache.size();
+    }
+
+    // LRU缓存类中添加remove()方法
+    bool remove(uint64_t key) {
+        auto it = cache.find(key);
+        if (it == cache.end()) {
+            return false; // 键不存在
+        }
+
+        // 从LRU列表中移除
+        lru_list.erase(lru_map[key]);
+
+        // 从映射中移除
+        lru_map.erase(key);
+
+        // 从缓存中移除
+        cache.erase(key);
+
+        return true;
+    }
+};
+
 class CXLController : public CXLSwitch {
 public:
     std::vector<CXLMemExpander *> cur_expanders{};
@@ -87,6 +175,8 @@ class CXLController : public CXLSwitch {
     std::queue<lbr> ring_buffer;
     // rob info
     std::unordered_map<uint64_t, thread_info> thread_map;
+    // LRU cache
+    LRUCache lru_cache;
 
     explicit CXLController(std::array<Policy *, 4> p, int capacity, page_type page_type_, int epoch,
                            double dramlatency);
@@ -106,6 +196,11 @@ class CXLController : public CXLSwitch {
     void set_stats(mem_stats stats);
     static void set_process_info(const proc_info &process_info);
     static void set_thread_info(const proc_info &thread_info);
+    // 添加缓存访问方法
+    std::optional<uint64_t> access_cache(uint64_t addr, uint64_t timestamp) { return lru_cache.get(addr, timestamp); }
+
+    // 添加缓存更新方法
+    void update_cache(uint64_t addr, uint64_t value, uint64_t timestamp) { lru_cache.put(addr, value, timestamp); }
 };
 
 template <> struct std::formatter<CXLController> {
@@ -206,6 +301,7 @@ template <> struct std::formatter<CXLController> {
         result += "\nStatistics:\n";
         result += std::format("  Number of Switches: {}\n", controller.num_switches);
         result += std::format("  Number of Endpoints: {}\n", controller.num_end_points);
+        result += std::format("  Number of Threads created: {}\n", controller.thread_map.size());
         result += std::format("  Memory Freed: {} bytes\n", controller.freed);
 
         return format_to(ctx.out(), "{}", result);

include/cxlendpoint.h

@@ -17,7 +17,6 @@
 #include <list>
 #include <queue>
 #include <map>
-#include <string>
 #include <tuple>
 #include <unordered_set>
 #include <vector>
@@ -75,6 +74,21 @@ class CXLMemExpander : public CXLEndPoint {
     int epoch = 0;
     uint64_t last_timestamp = 0;
     int id = -1;
+    struct AddressRange {
+        uint64_t start;
+        uint64_t end;
+
+        // 添加比较运算符，用于二分查找
+        bool operator<(const AddressRange& other) const {
+            return end < other.start;
+        }
+
+        bool operator<(uint64_t addr) const {
+            return end < addr;
+        }
+    };
+    std::vector<AddressRange> address_ranges;
+
     CXLMemExpander(int read_bw, int write_bw, int read_lat, int write_lat, int id, int capacity);
     std::vector<std::tuple<uint64_t, uint64_t>> get_access(uint64_t timestamp) override;
     void set_epoch(int epoch) override;
@@ -86,25 +100,50 @@ class CXLMemExpander : public CXLEndPoint {
     void delete_entry(uint64_t addr, uint64_t length) override;
     void update_address_cache() {
         if (cache_valid) return;
-
         address_cache.clear();
-        for (const auto& occ : occupation) {
+        for (const auto& occ : occupation)
             address_cache.insert(occ.address);
-        }
         cache_valid = true;
     }
     // 当 occupation 更新时调用此函数
     void invalidate_cache() {
         cache_valid = false;
     }
 
-    // 检查地址是否在 occupation 中
-    bool is_address_local(uint64_t addr) {
-        if (!cache_valid) {
-            update_address_cache();
+    void update_range_cache() {
+        if (cache_valid) return;
+        address_ranges.clear();
+        // 排序occupation以便合并连续地址
+        std::sort(occupation.begin(), occupation.end(),
+                 [](const auto& a, const auto& b) { return a.address < b.address; });
+        if (occupation.empty()) {
+            cache_valid = true;
+            return;
+        }
+        AddressRange current{occupation[0].address, occupation[0].address};
+        for (size_t i = 1; i < occupation.size(); i++) {
+            if (occupation[i].address == current.end + 1) {
+                // 连续地址，扩展范围
+                current.end = occupation[i].address;
+            } else {
+                // 新范围
+                address_ranges.push_back(current);
+                current = {occupation[i].address, occupation[i].address};
+            }
         }
+        address_ranges.push_back(current);
+        cache_valid = true;
+    }
 
-        return address_cache.find(addr) != address_cache.end();
+    bool is_address_local(uint64_t addr) {
+        if (!cache_valid)
+            update_range_cache();
+        // 使用标准库的二分查找，查找第一个"不小于"addr的元素
+        auto it = std::lower_bound(address_ranges.begin(), address_ranges.end(), addr);
+        // 如果找到了范围，且addr在这个范围内
+        if (it != address_ranges.end() && addr >= it->start && addr <= it->end)
+            return true;
+        return false;
     }
 };
 class CXLSwitch : public CXLEndPoint {

include/policy.h

@@ -53,5 +53,56 @@ class FIFOPolicy : public CachingPolicy {
     FIFOPolicy() = default;
     int compute_once(CXLController *) override;
 };
+// 基于访问频率的后向失效策略
+class FrequencyBasedInvalidationPolicy : public CachingPolicy {
+private:
+    std::unordered_map<uint64_t, uint64_t> access_count;  // 地址到访问计数的映射
+    uint64_t access_threshold;  // 访问阈值
+    uint64_t last_cleanup;      // 上次清理时间戳
+    uint64_t cleanup_interval;  // 清理间隔
 
+public:
+    explicit FrequencyBasedInvalidationPolicy(uint64_t threshold = 100, uint64_t interval = 10000000)
+        : access_threshold(threshold), last_cleanup(0), cleanup_interval(interval) {}
+
+    bool should_cache(uint64_t addr, uint64_t timestamp) {
+        // 记录访问
+        access_count[addr]++;
+        return true; // 总是缓存
+    }
+
+    bool should_invalidate(uint64_t addr, uint64_t timestamp) {
+        // 根据访问频率决定是否应该失效
+        auto it = access_count.find(addr);
+        if (it != access_count.end()) {
+            return it->second < access_threshold;
+        }
+        return false;
+    }
+
+    std::vector<uint64_t> get_invalidation_list(CXLController* controller) {
+        std::vector<uint64_t> to_invalidate;
+
+        // 遍历缓存查找低频访问的地址
+        for (const auto& [addr, entry] : controller->lru_cache.cache) {
+            if (should_invalidate(addr, 0)) {
+                to_invalidate.push_back(addr);
+            }
+        }
+
+        // 清理访问计数（周期性）
+        uint64_t current_time = controller->last_timestamp;
+        if (current_time - last_cleanup > cleanup_interval) {
+            access_count.clear();
+            last_cleanup = current_time;
+        }
+
+        return to_invalidate;
+    }
+
+    int compute_once(CXLController* controller) override {
+        // 如果有需要失效的地址，返回正数
+        return !get_invalidation_list(controller).empty() ? 1 : 0;
+    }
+};
 #endif // CXLMEMSIM_POLICY_H

microbench/st.cpp

@@ -46,6 +46,7 @@
   "add $" STR(MOVE_SIZE) ", %%r8 \n"				\
   "cmp $" STR(FENCE_BOUND) ",%%r8\n"				\
   "jl LOOP_START%= \n"						\
+  "clflush (%%r9) \n"					\
   "mfence \n"
 
 

microbench/st_serial.cpp

@@ -45,6 +45,7 @@
   "movdqa  %%xmm1, (%%r9) \n"					\
   "add $" STR(MOVE_SIZE) ", %%r8 \n"				\
   "cmp $" STR(FENCE_BOUND) ",%%r8\n"				\
+   "clflush (%%r9) \n"					\
   "mfence \n" \
   "jl LOOP_START%= \n"
 

src/cxlcontroller.cpp

@@ -46,7 +46,7 @@ CXLController::CXLController(std::array<Policy *, 4> p, int capacity, page_type
                              double dramlatency)
     : CXLSwitch(0), capacity(capacity), allocation_policy(dynamic_cast<AllocationPolicy *>(p[0])),
       migration_policy(dynamic_cast<MigrationPolicy *>(p[1])), paging_policy(dynamic_cast<PagingPolicy *>(p[2])),
-      caching_policy(dynamic_cast<CachingPolicy *>(p[3])), page_type_(page_type_), dramlatency(dramlatency) {
+      caching_policy(dynamic_cast<CachingPolicy *>(p[3])), page_type_(page_type_), dramlatency(dramlatency), lru_cache(32 * 1024 * 1024 / 64) {
     for (auto switch_ : this->switches) {
         switch_->set_epoch(epoch);
     }
@@ -56,7 +56,6 @@ CXLController::CXLController(std::array<Policy *, 4> p, int capacity, page_type
     // TODO get LRU wb
     // TODO BW type series
     // TODO cache
-    // TODO back invalidation
     // deferentiate R/W for multi reader multi writer
 }
 
@@ -130,9 +129,7 @@ void CXLController::insert_one(thread_info &t_info, lbr &lbr) {
         ring_buffer.pop();
     }
 }
-
 int CXLController::insert(uint64_t timestamp, uint64_t tid, uint64_t phys_addr, uint64_t virt_addr, int index) {
-    auto res = true;
     auto &t_info = thread_map[tid];
 
     // 计算时间步长,使timestamp均匀分布
@@ -142,31 +139,54 @@ int CXLController::insert(uint64_t timestamp, uint64_t tid, uint64_t phys_addr,
     }
     uint64_t current_timestamp = last_timestamp;
 
+    bool res = true;
     for (int i = last_index; i < index; i++) {
         // 更新当前时间戳
         current_timestamp += time_step;
 
+        // 首先检查LRU缓存
+        auto cache_result = access_cache(phys_addr, current_timestamp);
+
+        if (cache_result.has_value()) {
+            // 缓存命中
+            this->counter.inc_local();
+            t_info.llcm_type.push(0);  // 本地访问类型
+            continue;
+        }
+
+        // 缓存未命中，决定分配策略
         auto numa_policy = allocation_policy->compute_once(this);
+
         if (numa_policy == -1) {
+            // 本地访问
             this->occupation.emplace(current_timestamp, phys_addr);
             this->counter.inc_local();
             t_info.llcm_type.push(0);
-            continue;
-        }
-        this->counter.inc_remote();
-        for (auto switch_ : this->switches) {
-            res &= switch_->insert(current_timestamp, tid, phys_addr, virt_addr, numa_policy);
-        }
-        for (auto expander_ : this->expanders) {
-            res &= expander_->insert(current_timestamp, tid, phys_addr, virt_addr, numa_policy);
+
+            // 更新缓存
+            update_cache(phys_addr, phys_addr, current_timestamp);  // 使用物理地址作为值
+        } else {
+            // 远程访问
+            this->counter.inc_remote();
+            for (auto switch_ : this->switches) {
+                res &= switch_->insert(current_timestamp, tid, phys_addr, virt_addr, numa_policy);
+            }
+            for (auto expander_ : this->expanders) {
+                res &= expander_->insert(current_timestamp, tid, phys_addr, virt_addr, numa_policy);
+            }
+            t_info.llcm_type.push(1);  // 远程访问类型
+            // 可以选择是否缓存远程访问的数据
+            if (caching_policy->compute_once(this)) {
+                counter.inc_hitm();
+                update_cache(phys_addr, phys_addr, current_timestamp);
+            }
         }
-        t_info.llcm_type.push(1);
     }
 
     // 更新最后的索引和时间戳
     last_index = index;
     last_timestamp = timestamp;
-    return res; // 返回实际的结果而不是固定的true
+    return res;
 }
 int CXLController::insert(uint64_t timestamp, uint64_t tid, lbr lbrs[32], cntr counters[32]) {
     // 处理LBR记录