add monitor wait and bpftime is_lock

Author: vickiegpt

artifact/mlc-cxlmemsim.txt

@@ -0,0 +1,109 @@
+Intel(R) Memory Latency Checker - v3.11b
+Measuring idle latencies for sequential access (in ns)...
+		Numa node
+Numa node	     0
+       0	 292.9
+
+Measuring Peak Injection Memory Bandwidths for the system
+Bandwidths are in MB/sec (1 MB/sec = 1,000,000 Bytes/sec)
+Using all the threads from each core if Hyper-threading is enabled
+Using traffic with the following read-write ratios
+ALL Reads        :	31031.7
+3:1 Reads-Writes :	43700.9
+2:1 Reads-Writes :	42475.2
+1:1 Reads-Writes :	45973.2
+Stream-triad like:	28339.2
+
+Measuring Memory Bandwidths between nodes within system
+Bandwidths are in MB/sec (1 MB/sec = 1,000,000 Bytes/sec)
+Using all the threads from each core if Hyper-threading is enabled
+Using Read-only traffic type
+		Numa node
+Numa node	     0
+       0	50459.9
+
+Measuring Loaded Latencies for the system
+Using all the threads from each core if Hyper-threading is enabled
+Using Read-only traffic type
+Inject	Latency	Bandwidth
+Delay	(ns)	MB/sec
+==========================
+ 00000	708.06	  50473.7
+ 00002	713.23	  50408.7
+ 00008	718.64	  50425.6
+ 00015	696.64	  50381.3
+ 00050	637.99	  50585.4
+ 00100	586.28	  50597.8
+ 00200	567.09	  50641.2
+ 00300	512.45	  50732.0
+ 00400	469.48	  50550.7
+ 00500	317.21	  44991.4
+ 00700	216.09	  33815.6
+ 01000	188.95	  24427.9
+ 01300	178.91	  19323.6
+ 01700	175.15	  15074.7
+ 02500	168.75	  10480.7
+ 03500	164.78	   7691.6
+ 05000	161.10	   5543.5
+ 09000	155.73	   3291.7
+ 20000	174.09	   1668.7
+
+Measuring cache-to-cache transfer latency (in ns)...
+Local Socket L2->L2 HIT  latency	65.4
+Local Socket L2->L2 HITM latency	78.6
+
+Exiting...
+
+
+========== Process 0[tgid=1003083, tid=1003083] statistics summary ==========
+emulated time =264.9391297
+total delay   =90.98129678699999
+PEBS sample total 692 267577
+LBR sample total 10
+bpftime sample total 112362
+CXLController:
+Total system memory capacity: 60GB
+  Page Type: PAGE
+  Global Counter:
+    Local: 0
+    Remote: 611
+    HITM: 552085377
+Topology:
+Switch:
+  Events:
+    Load: 0
+    Store: 0
+    Conflict: 15
+  Switch:
+    Events:
+      Load: 0
+      Store: 408
+      Conflict: 57
+    Expander:
+      Events:
+        Load: 0
+        Store: 204
+        Migrate in: 0
+        Migrate out: 0
+        Hit Old: 0
+    Expander:
+      Events:
+        Load: 0
+        Store: 204
+        Migrate in: 0
+        Migrate out: 0
+        Hit Old: 0
+  Expander:
+    Events:
+      Load: 0
+      Store: 203
+      Migrate in: 0
+      Migrate out: 0
+      Hit Old: 0
+
+Statistics:
+  Number of Switches: 2
+  Number of Endpoints: 3
+  Number of Threads created: 1
+  Memory Freed: 1011780 bytes
+

include/bpftimeruntime.h

@@ -17,16 +17,48 @@
 #include <linux/bpf.h>
 #include <string>
 #include <sys/types.h>
+#include "bpftime_config.hpp"
+#include "bpftime_logger.hpp"
+#include "bpftime_shm.hpp"
+template <typename K, typename V>
+class BPFUpdater {
+public:
+    int map_fd;
+    BPFUpdater(int map_fd) : map_fd(map_fd) {}
+
+    void update(K key, V value) {
+        int key1 = 0;
+        bpftime_map_get_next_key(map_fd, &key1, &key); // process map
+        auto item2 = (struct proc_info *)bpftime_map_lookup_elem(map_fd, &key); // allocs map
+        item2->sleep_time = (uint64_t)value;
+        int ret = bpftime_map_update_elem(map_fd, &key, item2, BPF_ANY);
+        if (ret != 0) {
+            SPDLOG_ERROR("Error updating map: {}\n", strerror(errno));
+            throw std::runtime_error("Error updating the bpf map");
+        }
+    }
 
+    bool get(K key) {
+        int key1 = 0;
+        bpftime_map_get_next_key(map_fd, &key1, &key); // process map
+        auto item2 = (struct proc_info *)bpftime_map_lookup_elem(map_fd, &key); // allocs map
+        if (item2 == nullptr) {
+            return false;
+        }
+        return item2->is_locked;
+    }
+};
 class BpfTimeRuntime {
 public:
     BpfTimeRuntime(pid_t, std::string);
     ~BpfTimeRuntime();
 
     int read(CXLController *, BPFTimeRuntimeElem *);
-
+    BPFUpdater<uint64_t,uint64_t> *updater;
     pid_t tid;
 };
+
+
 #define u64 unsigned long long
 #define u32 unsigned int
 #else
@@ -62,6 +94,7 @@ struct proc_info {
     u64 current_pid; // 当前进程 ID
     u64 current_tid; // 当前线程 ID
     u64 sleep_time; // 睡眠时间
+    bool is_locked; // 是否锁定
     struct mem_info mem_info;
 };
 

include/cxlcontroller.h

@@ -66,7 +66,7 @@ class MigrationPolicy : public Policy {
 class PagingPolicy : public Policy {
 public:
     PagingPolicy();
-    int compute_once(CXLController *) override{};
+    int compute_once(CXLController *) override{return 0;};
     // paging related
     virtual uint64_t check_page_table_walk(uint64_t virt_addr, uint64_t phys_addr, bool is_remote, page_type pt) {
         return 0;

include/cxlendpoint.h

@@ -157,7 +157,7 @@ class CXLSwitch : public CXLEndPoint {
     // TODO get the approximate congestion and target done time
     std::unordered_map<uint64_t, uint64_t> timeseries_map;
 
-    double congestion_latency = 90; // 200ns is the latency of the switch
+    double congestion_latency = 0.02; // 200ns is the latency of the switch
     explicit CXLSwitch(int id);
     std::vector<std::tuple<uint64_t, uint64_t>> get_access(uint64_t timestamp) override;
     double calculate_latency(const std::vector<std::tuple<uint64_t, uint64_t>> &elem,

include/lbr.h

@@ -37,12 +37,9 @@ struct lbr_sample {
     perf_event_header header;
     uint32_t pid;
     uint32_t tid;
-    // uint64_t nr;
-    // uint64_t ips[4];
     uint64_t timestamp;
     uint32_t cpu;
     uint64_t nr2;
-    // uint64_t hw_idx;
     lbr lbrs[32];
     cntr counters[32];
 };

include/monitor.h

@@ -60,7 +60,8 @@ class Monitor {
     std::mutex wanted_delay_mutex;
     timespec injected_delay; // recorded time for injected
     timespec wasted_delay; // recorded time for calling between continue and calculation
-    timespec squabble_delay; // inj-was
+    constexpr static timespec interval_delay = {0,10000000}; // inj-was
+    static timespec last_delay; // last delay
     Elem elem[2]; // before & after
     Elem *before, *after;
     double total_delay;
@@ -72,7 +73,7 @@ class Monitor {
 
     Monitor(const Monitor &other)
         : tgid(other.tgid), tid(other.tid), cpu_core(other.cpu_core), wanted_delay(other.wanted_delay),
-          injected_delay(other.injected_delay), squabble_delay(other.squabble_delay),
+          injected_delay(other.injected_delay),
           before(nullptr), // Will be set after copying elements
           after(nullptr), // Will be set after copying elements
           total_delay(other.total_delay), start_exec_ts(other.start_exec_ts), end_exec_ts(other.end_exec_ts),

include/policy.h

@@ -90,7 +90,7 @@ class HeatAwareMigrationPolicy : public MigrationPolicy {
 };
 
 class HugePagePolicy : public PagingPolicy {
-private:
+public:
     // 页表遍历延迟基准值（纳秒）
     uint64_t ptw_base_latency_local; // 本地内存页表遍历基准延迟
     uint64_t ptw_base_latency_remote; // 远程内存页表遍历基准延迟
@@ -145,7 +145,6 @@ class HugePagePolicy : public PagingPolicy {
     TLBCache tlb_2m; // 2MB页面的TLB
     TLBCache tlb_1g; // 1GB页面的TLB
     CXLHugePageEvent stats; // 统计信息
-public:
     explicit HugePagePolicy(uint64_t local_latency = 100, uint64_t remote_latency = 300)
         : ptw_base_latency_local(local_latency), ptw_base_latency_remote(remote_latency),
           tlb_4k(64), // 4KB页面TLB容量(较大)
@@ -331,7 +330,7 @@ class HugePagePolicy : public PagingPolicy {
 };
 
 class PageTableAwarePolicy : public PagingPolicy {
-private:
+public:
     // 页表缓存，用于追踪已经转换过的虚拟地址
     std::unordered_map<uint64_t, uint64_t> va_pa_cache;
     // 页表访问延迟（纳秒）
@@ -344,7 +343,6 @@ class PageTableAwarePolicy : public PagingPolicy {
     // 清理间隔
     uint64_t cleanup_interval;
 
-public:
     explicit PageTableAwarePolicy(uint64_t local_latency = 100, uint64_t remote_latency = 300,
                                   uint64_t cleanup_interval = 10000000)
         : ptw_latency_local(local_latency), ptw_latency_remote(remote_latency), last_cleanup_timestamp(0),
@@ -425,6 +423,19 @@ class FIFOPolicy : public CachingPolicy {
 public:
     FIFOPolicy() = default;
     int compute_once(CXLController *) override;
+    std::vector<uint64_t> get_invalidation_list(CXLController *controller) override {
+        std::vector<uint64_t> to_invalidate;
+        for (const auto &[timestamp, info] : controller->occupation) {
+            to_invalidate.push_back(info.address);
+        }
+        return to_invalidate;
+    };
+    bool should_cache(uint64_t addr, uint64_t timestamp) override {
+        return false;
+    };
+    bool should_invalidate(uint64_t addr, uint64_t timestamp) override {
+        return false;
+    };
 };
 
 // 基于访问频率的后向失效策略
@@ -547,12 +558,11 @@ class FrequencyBasedMigrationPolicy : public MigrationPolicy {
 
 // 基于负载平衡的迁移策略
 class LoadBalancingMigrationPolicy : public MigrationPolicy {
-private:
+public:
     double imbalance_threshold; // 负载不平衡阈值
     uint64_t migration_interval; // 迁移间隔
     uint64_t last_migration; // 上次迁移时间
 
-public:
     LoadBalancingMigrationPolicy(double threshold = 0.2, uint64_t interval = 5000000)
         : imbalance_threshold(threshold), migration_interval(interval), last_migration(0) {}
 
@@ -706,12 +716,11 @@ class LoadBalancingMigrationPolicy : public MigrationPolicy {
 
 // 基于局部性的迁移策略
 class LocalityBasedMigrationPolicy : public MigrationPolicy {
-private:
+public:
     std::unordered_map<uint64_t, std::vector<uint64_t>> page_access_pattern; // 页面访问模式
     uint64_t pattern_threshold; // 模式识别阈值
     uint64_t page_size; // 页面大小
 
-public:
     LocalityBasedMigrationPolicy(uint64_t threshold = 5, uint64_t p_size = 4096)
         : pattern_threshold(threshold), page_size(p_size) {}
 
@@ -780,10 +789,9 @@ class LocalityBasedMigrationPolicy : public MigrationPolicy {
 
 // 基于数据寿命的迁移策略
 class LifetimeBasedMigrationPolicy : public MigrationPolicy {
-private:
+public:
     uint64_t lifetime_threshold; // 数据寿命阈值
 
-public:
     LifetimeBasedMigrationPolicy(uint64_t threshold = 1000000) : lifetime_threshold(threshold) {}
 
     int compute_once(CXLController *controller) override {
@@ -828,10 +836,9 @@ class LifetimeBasedMigrationPolicy : public MigrationPolicy {
 
 // 混合多策略迁移
 class HybridMigrationPolicy : public MigrationPolicy {
-private:
+public:
     std::vector<MigrationPolicy *> policies; // 多个迁移策略
 
-public:
     HybridMigrationPolicy() {}
 
     // 添加策略

include/rob.h

@@ -34,6 +34,7 @@ class Rob {
     const size_t maxSize_;
     std::deque<InstructionGroup> queue_; // ROB队列
     int64_t stallCount_ = 0; // 停顿计数
+    int64_t stallEventCount_ = 0; // 停顿事件计数
     int64_t cur_latency = 0;
     int64_t totalLatency_ = 0;
     int64_t currentCycle_ = 0; // 当前周期
@@ -46,6 +47,7 @@ class Rob {
 
     // 性能统计
     int64_t getStallCount() const { return stallCount_; }
+    int64_t getStallEventCount() const { return stallEventCount_;}
     int64_t getCurrentCycle() const { return currentCycle_; }
     double getAverageLatency() const { return queue_.empty() ? 0 : static_cast<double>(totalLatency_) / queue_.size(); }
 };

microbench/ld.cpp

@@ -26,7 +26,7 @@
 #define STR(x) STR_HELPER(x)
 
 #define MOVE_SIZE 128
-#define MAP_SIZE  (long)(1024 * 1024 * 1024)
+#define MAP_SIZE  (long)( 1024)
 #define CACHELINE_SIZE  64
 
 #ifndef FENCE_COUNT

microbench/ld_serial.cpp

@@ -27,7 +27,7 @@
 #define STR(x) STR_HELPER(x)
 
 #define MOVE_SIZE 128
-#define MAP_SIZE  (long)(1024 * 1024 * 1024)
+#define MAP_SIZE  (long)(1024)
 #define CACHELINE_SIZE  64
 
 #ifndef FENCE_COUNT