fall back to Ubuntu20

Your Name · Your Name · commit 16ed6b5c8f2c · 2025-10-29T16:22:55.000-07:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -9,7 +9,7 @@ endif ()
 execute_process(COMMAND uname -r OUTPUT_VARIABLE arch OUTPUT_STRIP_TRAILING_WHITESPACE)
 set(LINUX_SOURCE /lib/modules/${arch}/build/)
 
-set(CMAKE_CXX_STANDARD 26)
+set(CMAKE_CXX_STANDARD 20)
 
 # Add option for server mode (disables bpftime dependencies)
 option(SERVER_MODE "Build in server mode without bpftime dependencies" OFF)
diff --git a/include/cxlcontroller.h b/include/cxlcontroller.h
@@ -275,111 +275,110 @@ class CXLController : public CXLSwitch {
     void invalidate_in_switch(CXLSwitch *switch_, uint64_t addr);
 };
 
-template <> struct std::formatter<CXLController> {
-    // Parse function to handle any format specifiers (if needed)
-    constexpr auto parse(std::format_parse_context &ctx) -> decltype(ctx.begin()) {
-        // If you have specific format specifiers, parse them here
-        // For simplicity, we'll ignore them and return the end iterator
-        return ctx.end();
-    }
-
-    // Format function to output the Monitors data
+// C++20 doesn't have std::formatter - using fmt::formatter instead
+// We'll use a helper function instead
+namespace fmt {
+    template <> struct formatter<CXLController> {
+        constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
+            return ctx.end();
+        }
 
-    template <typename FormatContext>
-    auto format(const CXLController &controller, FormatContext &ctx) const -> decltype(ctx.out()) {
-        std::string result;
+        template <typename FormatContext>
+        auto format(const CXLController &controller, FormatContext &ctx) const -> decltype(ctx.out()) {
+            std::string result;
 
-        // 首先打印控制器自身的计数器信息
-        result += std::format("CXLController:\n");
-        // iterate through the topology map
-        uint64_t total_capacity = 0;
+            // 首先打印控制器自身的计数器信息
+            result += "CXLController:\n";
+            // iterate through the topology map
+            uint64_t total_capacity = 0;
 
-        std::function<void(const CXLSwitch *)> dfs_capacity = [&](const CXLSwitch *node) {
-            if (!node)
-                return;
+            std::function<void(const CXLSwitch *)> dfs_capacity = [&](const CXLSwitch *node) {
+                if (!node)
+                    return;
 
-            // Traverse expanders and sum their capacity
-            for (const auto *expander : node->expanders) {
-                if (expander) {
-                    total_capacity += expander->capacity;
+                // Traverse expanders and sum their capacity
+                for (const auto *expander : node->expanders) {
+                    if (expander) {
+                        total_capacity += expander->capacity;
+                    }
                 }
-            }
 
-            // Recur for all connected switches
-            for (const auto *sw : node->switches) {
-                dfs_capacity(sw); // Proper recursive call
-            }
-        };
-        dfs_capacity(&controller);
-
-        result += std::format("Total system memory capacity: {}GB\n", total_capacity);
-
-        result += std::format("  Page Type: {}\n", [](page_type pt) {
-            switch (pt) {
-            case CACHELINE:
-                return "CACHELINE";
-            case PAGE:
-                return "PAGE";
-            case HUGEPAGE_2M:
-                return "HUGEPAGE_2M";
-            case HUGEPAGE_1G:
-                return "HUGEPAGE_1G";
-            default:
-                return "UNKNOWN";
-            }
-        }(controller.page_type_));
-
-        // 打印全局计数器
-        result += std::format("  Global Counter:\n");
-        result += std::format("    Local: {}\n", controller.counter.local.get());
-        result += std::format("    Remote: {}\n", controller.counter.remote.get());
-        result += std::format("    HITM: {}\n", controller.counter.hitm.get());
-
-        // 打印拓扑结构（交换机和端点）
-        result += "Topology:\n";
-
-        // 递归打印每个交换机
-        std::function<void(const CXLSwitch *, int)> print_switch = [&result, &print_switch](const CXLSwitch *sw,
-                                                                                            int depth) {
-            std::string indent(depth * 2, ' ');
-
-            // 打印交换机事件计数
-            result += std::format("{}Switch:\n", indent);
-            result += std::format("{}  Events:\n", indent);
-            result += std::format("{}    Load: {}\n", indent, sw->counter.load.get());
-            result += std::format("{}    Store: {}\n", indent, sw->counter.store.get());
-            result += std::format("{}    Conflict: {}\n", indent, sw->counter.conflict.get());
-
-            // 递归打印子交换机
-            for (const auto &child : sw->switches) {
-                print_switch(child, depth + 1);
-            }
+                // Recur for all connected switches
+                for (const auto *sw : node->switches) {
+                    dfs_capacity(sw); // Proper recursive call
+                }
+            };
+            dfs_capacity(&controller);
+
+            result += fmt::format("Total system memory capacity: {}GB\n", total_capacity);
+
+            result += fmt::format("  Page Type: {}\n", [](page_type pt) {
+                switch (pt) {
+                case CACHELINE:
+                    return "CACHELINE";
+                case PAGE:
+                    return "PAGE";
+                case HUGEPAGE_2M:
+                    return "HUGEPAGE_2M";
+                case HUGEPAGE_1G:
+                    return "HUGEPAGE_1G";
+                default:
+                    return "UNKNOWN";
+                }
+            }(controller.page_type_));
+
+            // 打印全局计数器
+            result += fmt::format("  Global Counter:\n");
+            result += fmt::format("    Local: {}\n", controller.counter.local.get());
+            result += fmt::format("    Remote: {}\n", controller.counter.remote.get());
+            result += fmt::format("    HITM: {}\n", controller.counter.hitm.get());
+
+            // 打印拓扑结构（交换机和端点）
+            result += "Topology:\n";
+
+            // 递归打印每个交换机
+            std::function<void(const CXLSwitch *, int)> print_switch = [&result, &print_switch](const CXLSwitch *sw,
+                                                                                                int depth) {
+                std::string indent(depth * 2, ' ');
+
+                // 打印交换机事件计数
+                result += fmt::format("{}Switch:\n", indent);
+                result += fmt::format("{}  Events:\n", indent);
+                result += fmt::format("{}    Load: {}\n", indent, sw->counter.load.get());
+                result += fmt::format("{}    Store: {}\n", indent, sw->counter.store.get());
+                result += fmt::format("{}    Conflict: {}\n", indent, sw->counter.conflict.get());
+
+                // 递归打印子交换机
+                for (const auto &child : sw->switches) {
+                    print_switch(child, depth + 1);
+                }
 
-            // 打印端点
-            for (const auto &endpoint : sw->expanders) {
-                result += std::format("{}Expander:\n", indent + "  ");
-                result += std::format("{}  Events:\n", indent + "  ");
-                result += std::format("{}    Load: {}\n", indent + "  ", endpoint->counter.load.get());
-                result += std::format("{}    Store: {}\n", indent + "  ", endpoint->counter.store.get());
-                result += std::format("{}    Migrate in: {}\n", indent + "  ", endpoint->counter.migrate_in.get());
-                result += std::format("{}    Migrate out: {}\n", indent + "  ", endpoint->counter.migrate_out.get());
-                result += std::format("{}    Hit Old: {}\n", indent + "  ", endpoint->counter.hit_old.get());
-            }
-        };
+                // 打印端点
+                for (const auto &endpoint : sw->expanders) {
+                    result += fmt::format("{}Expander:\n", indent + "  ");
+                    result += fmt::format("{}  Events:\n", indent + "  ");
+                    result += fmt::format("{}    Load: {}\n", indent + "  ", endpoint->counter.load.get());
+                    result += fmt::format("{}    Store: {}\n", indent + "  ", endpoint->counter.store.get());
+                    result += fmt::format("{}    Migrate in: {}\n", indent + "  ", endpoint->counter.migrate_in.get());
+                    result += fmt::format("{}    Migrate out: {}\n", indent + "  ", endpoint->counter.migrate_out.get());
+                    result += fmt::format("{}    Hit Old: {}\n", indent + "  ", endpoint->counter.hit_old.get());
+                }
+            };
 
-        // 从控制器开始递归打印
-        print_switch(&controller, 0);
+            // 从控制器开始递归打印
+            print_switch(&controller, 0);
 
-        // 打印额外的统计信息
-        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);
+            // 打印额外的统计信息
+            result += "\nStatistics:\n";
+            result += fmt::format("  Number of Switches: {}\n", controller.num_switches);
+            result += fmt::format("  Number of Endpoints: {}\n", controller.num_end_points);
+            result += fmt::format("  Number of Threads created: {}\n", controller.thread_map.size());
+            result += fmt::format("  Memory Freed: {} bytes\n", controller.freed);
 
-        return format_to(ctx.out(), "{}", result);
-    }
-};
+            return format_to(ctx.out(), "{}", result);
+        }
+    };
+}
 
 extern CXLController *controller;
 #endif // CXLMEMSIM_CXLCONTROLLER_H
diff --git a/include/cxlcounter.h b/include/cxlcounter.h
@@ -15,8 +15,6 @@
 #include <concepts>
 #include <cstdint>
 #include <optional>
-#include <format>
-#include <source_location>
 #include <string>
 /** TODO: Whether to using the pebs to record the state. add back invalidation migrate huge/ page and prefetch*/
 const char loadName[] = "load";
@@ -64,9 +62,10 @@ template <const char *Name> class AtomicCounter {
     constexpr operator uint64_t() const noexcept { return get(); }
 
     // 用于可能需要记录的事件日志 (For event logs that may need to be recorded)
-    void log_increment(std::source_location loc = std::source_location::current()) const {
-        // 未来可以实现日志记录 (Logging can be implemented in the future)
-    }
+    // Note: std::source_location is C++20, but not all compilers support it yet
+    // void log_increment(std::source_location loc = std::source_location::current()) const {
+    //     // 未来可以实现日志记录 (Logging can be implemented in the future)
+    // }
 };
 // 确保AtomicCounter满足Counter概念 (Ensure AtomicCounter meets the Counter concept)
 template <const char *Name>
@@ -75,16 +74,17 @@ inline constexpr bool implements_counter_concept = requires(AtomicCounter<Name>
     { t.increment() } -> std::same_as<void>;
 };
 
-template <const char *Name> struct std::formatter<AtomicCounter<Name>> {
-    constexpr auto parse(std::format_parse_context &ctx) -> decltype(ctx.begin()) { return ctx.end(); }
-
-    template <typename FormatContext>
-    auto format(const AtomicCounter<Name> &counter, FormatContext &ctx) const -> decltype(ctx.out()) {
-        // 简化formatter实现，避免嵌套std::format调用 (Simplify formatter implementation, avoid nested std::format
-        // calls)
-        return format_to(ctx.out(), "{}", counter.get());
-    }
-};
+// C++20 doesn't have std::formatter - this requires C++20 with fmt library
+// template <const char *Name> struct std::formatter<AtomicCounter<Name>> {
+//     constexpr auto parse(std::format_parse_context &ctx) -> decltype(ctx.begin()) { return ctx.end(); }
+//
+//     template <typename FormatContext>
+//     auto format(const AtomicCounter<Name> &counter, FormatContext &ctx) const -> decltype(ctx.out()) {
+//         // 简化formatter实现，避免嵌套std::format调用 (Simplify formatter implementation, avoid nested std::format
+//         // calls)
+//         return format_to(ctx.out(), "{}", counter.get());
+//     }
+// };
 
 // 使用C++20的enum class和强类型枚举 (Use C++20 enum class and strong-typed enumerations)
 enum class EventType { Load, Store, Conflict, MigrateIn, MigrateOut, HitOld, Local, Remote, Hitm };
diff --git a/include/rdma_communication.h b/include/rdma_communication.h
@@ -136,7 +136,7 @@ class RDMATransport {
             if (std::string(mode) == "rdma") return MODE_RDMA;
             if (std::string(mode) == "shm") return MODE_SHM;
         }
-        return MODE_RDMA
+        return MODE_RDMA;
     }
 
     static bool is_rdma_available() {
diff --git a/src/incore.cpp b/src/incore.cpp
@@ -19,9 +19,9 @@ void pcm_cpuid(const unsigned leaf, CPUID_INFO *info) {
 }
 
 int Incore::start() {
-    int i, r = -1;
+    int r = -1;
 
-    for (i = 0; i < this->perf.size(); i++) {
+    for (size_t i = 0; i < this->perf.size(); i++) {
         r = this->perf[i]->start();
         if (r < 0) {
             SPDLOG_ERROR("perf_start failed. i:{}\n", i);
@@ -31,9 +31,9 @@ int Incore::start() {
     return r;
 }
 int Incore::stop() {
-    int i, r = -1;
+    int r = -1;
 
-    for (i = 0; i < this->perf.size(); i++) {
+    for (size_t i = 0; i < this->perf.size(); i++) {
         r = this->perf[i]->stop();
         if (r < 0) {
             SPDLOG_ERROR("perf_stop failed. i:{}\n", i);
@@ -45,8 +45,8 @@ int Incore::stop() {
 
 ssize_t Incore::read_cpu_elems(struct CPUElem *elem) {
     ssize_t r;
-    for (auto const &[idx, value] : this->perf | std::views::enumerate) {
-        r = value->read_pmu(&elem->cpu[idx]);
+    for (size_t idx = 0; idx < this->perf.size(); idx++) {
+        r = this->perf[idx]->read_pmu(&elem->cpu[idx]);
         if (r < 0) {
             SPDLOG_ERROR("read cpu_elems[{}] failed.\n", std::get<0>(helper.perf_conf.cpu[idx]));
         }
@@ -58,7 +58,7 @@ ssize_t Incore::read_cpu_elems(struct CPUElem *elem) {
 
 Incore::Incore(const pid_t pid, const int cpu, struct PerfConfig *perf_config) : perf_config(perf_config) {
     /* reset all pmc values */
-    for (int i = 0; i < perf_config->cpu.size(); i++) {
+    for (size_t i = 0; i < perf_config->cpu.size(); i++) {
         this->perf[i] = init_incore_perf(pid, cpu, std::get<1>(perf_config->cpu[i]), std::get<2>(perf_config->cpu[i]));
     }
 }
diff --git a/src/main.cc b/src/main.cc
@@ -180,13 +180,13 @@ int main(int argc, char *argv[]) {
     auto ncpu = helper.num_of_cpu();
     auto ncha = helper.num_of_cha();
     SPDLOG_DEBUG("tnum:{}", tnum);
-    for (auto const &[idx, value] : weight | std::views::enumerate) {
-        SPDLOG_DEBUG("weight[{}]:{}", weight_vec[idx], value);
+    for (size_t idx = 0; idx < weight.size(); idx++) {
+        SPDLOG_DEBUG("weight[{}]:{}", weight_vec[idx], weight[idx]);
     }
 
-    for (auto const &[idx, value] : capacity | std::views::enumerate) {
+    for (size_t idx = 0; idx < capacity.size(); idx++) {
         if (idx == 0) {
-            SPDLOG_DEBUG("local_memory_region capacity:{}", value);
+            SPDLOG_DEBUG("local_memory_region capacity:{}", capacity[idx]);
             controller = new CXLController({policy1, policy2, policy3, policy4}, capacity[0], mode, 100, dramlatency);
         } else {
             SPDLOG_DEBUG("memory_region:{}", (idx - 1) + 1);
@@ -284,10 +284,10 @@ int main(int argc, char *argv[]) {
 
     /* read CHA params */
     for (const auto &mon : monitors->mon) {
-        for (auto const &[idx, value] : pmu.chas | std::views::enumerate) {
+        for (size_t idx = 0; idx < pmu.chas.size(); idx++) {
             pmu.chas[idx].read_cha_elems(&mon.before->chas[idx]);
         }
-        for (auto const &[idx, value] : pmu.cpus | std::views::enumerate) {
+        for (size_t idx = 0; idx < pmu.cpus.size(); idx++) {
             pmu.cpus[idx].read_cpu_elems(&mon.before->cpus[idx]);
         }
     }
@@ -303,7 +303,8 @@ int main(int argc, char *argv[]) {
 
     while (true) {
         uint64_t calibrated_delay;
-        for (auto const &[i, mon] : monitors->mon | std::views::enumerate) {
+        for (size_t i = 0; i < monitors->mon.size(); i++) {
+            const auto &mon = monitors->mon[i];
             // check other process
             auto m_status = mon.status.load();
             if (m_status == MONITOR_DISABLE) {
@@ -336,13 +337,13 @@ int main(int argc, char *argv[]) {
                 }
                 target_llcmiss = mon.after->pebs.total - mon.before->pebs.total;
 
-                for (auto const &[idx, value] : pmu.cpus | std::views::enumerate) {
-                    value.read_cpu_elems(&mon.after->cpus[i]);
+                for (size_t idx = 0; idx < pmu.cpus.size(); idx++) {
+                    pmu.cpus[idx].read_cpu_elems(&mon.after->cpus[i]);
                     cpu_vec[idx] = mon.after->cpus[i].cpu[idx] - mon.before->cpus[i].cpu[idx];
                 }
 
-                for (auto const &[idx, value] : pmu.chas | std::views::enumerate) {
-                    value.read_cha_elems(&mon.after->chas[cha_mapping[i]]);
+                for (size_t idx = 0; idx < pmu.chas.size(); idx++) {
+                    pmu.chas[idx].read_cha_elems(&mon.after->chas[cha_mapping[i]]);
                     cha_vec[idx] = mon.after->chas[cha_mapping[i]].cha[idx] - mon.before->chas[cha_mapping[i]].cha[idx];
                 }
                 target_llchits = cpu_vec[0];
diff --git a/src/monitor.cpp b/src/monitor.cpp
diff --git a/src/rob.cc b/src/rob.cc
diff --git a/src/uncore.cpp b/src/uncore.cpp

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ class RDMATransport {`
`136`	`136`	`if (std::string(mode) == "rdma") return MODE_RDMA;`
`137`	`137`	`if (std::string(mode) == "shm") return MODE_SHM;`
`138`	`138`	`}`
`139`		`- return MODE_RDMA`
	`139`	`+ return MODE_RDMA;`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`static bool is_rdma_available() {`