【智鹿空间】c++实现了一个简单的链表数据结构 MyList，其中包含基本的 Get 和 Modify 操作，

李元豪2024-11-13 1:03

这段代码实现了一个简单的链表数据结构 MyList，其中包含基本的 Get 和 Modify 操作，并且支持多线程访问。此外，还使用了 EBR (Epoch-Based Reclamation) 技术来管理内存回收，以及 benchmark 库来进行性能测试。以下是对代码的逐行注释：

cpp 复制代码 
#include <benchmark/benchmark.h>  // 引入 Google Benchmark 库
#include <mutex>                  // 引入 C++ 标准库中的互斥锁
#include "ebr.h"                  // 引入 EBR (Epoch-Based Reclamation) 相关头文件
#include "spin_lock.h"            // 引入自旋锁相关头文件

// 定义链表节点结构
struct Node {
  Node() : lock(), next(nullptr) {}  // 构造函数，初始化锁和下一个指针
  int key;                           // 键值
  int value;                         // 值
  Node *next;                        // 指向下一个节点的指针
  SpinLock lock;                     // 自旋锁，用于保护节点
};

// 定义节点释放类，用于自动删除节点
class NodeFree {
 public:
  NodeFree(Node *node) { delete node; }  // 构造函数，删除传入的节点
};

// 定义链表类
class MyList {
 public:
  MyList() {
    Node *pre_node = nullptr;
    auto *&cur_node = root_;  // 当前节点指针
    for (int i = 0; i < 10; i++) {
      cur_node = new Node;     // 创建新节点
      cur_node->key = i;       // 设置键值
      cur_node->value = i;     // 设置值
      cur_node->next = pre_node;  // 设置下一个指针
      pre_node = cur_node;     // 更新前一个节点指针
    }
  }

  // 获取节点值
  int Get(int key, int *value) {
    root_->lock.lock();  // 锁住根节点
    auto *cur_node = root_->next;  // 当前节点指针
    auto *pre_node = root_;  // 前一个节点指针
    while (cur_node != nullptr) {
      cur_node->lock.lock();  // 锁住当前节点
      pre_node->lock.unlock();  // 解锁前一个节点
      if (key == cur_node->key) {  // 如果找到键值
        *value = cur_node->value;  // 设置返回值
        cur_node->lock.unlock();  // 解锁当前节点
        return 0;  // 返回成功
      }
      pre_node = cur_node;  // 更新前一个节点指针
      cur_node = cur_node->next;  // 移动到下一个节点
    }
    pre_node->lock.unlock();  // 解锁最后一个节点
    return 1;  // 返回失败
  }

  // 修改节点值
  int Modify(int key, int value) {
    root_->lock.lock();  // 锁住根节点
    auto *cur_node = root_->next;  // 当前节点指针
    auto *pre_node = root_;  // 前一个节点指针
    while (cur_node != nullptr) {
      cur_node->lock.lock();  // 锁住当前节点
      pre_node->lock.unlock();  // 解锁前一个节点
      if (key == cur_node->key) {  // 如果找到键值
        cur_node->value = value;  // 修改值
        cur_node->lock.unlock();  // 解锁当前节点
        return 0;  // 返回成功
      }
      pre_node = cur_node;  // 更新前一个节点指针
      cur_node = cur_node->next;  // 移动到下一个节点
    }
    pre_node->lock.unlock();  // 解锁最后一个节点
    return 1;  // 返回失败
  }

  // 使用 EBR 的获取节点值
  int GetUseEbr(int key, int *value) {
    ebr_mgr_.StartRead();  // 开始读操作
    auto *cur_node = root_->next;  // 当前节点指针
    while (cur_node != nullptr) {
      if (key == cur_node->key) {  // 如果找到键值
        *value = cur_node->value;  // 设置返回值
        ebr_mgr_.EndRead();  // 结束读操作
        return 0;  // 返回成功
      }
      cur_node = cur_node->next;  // 移动到下一个节点
    }
    ebr_mgr_.EndRead();  // 结束读操作
    return 1;  // 返回失败
  }

  // 使用 EBR 的修改节点值
  int ModifyUseEbr(int key, int value) {
    root_->lock.lock();  // 锁住根节点
    auto *cur_node = root_->next;  // 当前节点指针
    auto *pre_node = root_;  // 前一个节点指针
    while (cur_node != nullptr) {
      cur_node->lock.lock();  // 锁住当前节点
      if (key == cur_node->key) {  // 如果找到键值
        auto *new_node = new Node;  // 创建新节点
        new_node->key = cur_node->key;  // 设置键值
        new_node->value = value;  // 设置值
        new_node->next = cur_node->next;  // 设置下一个指针
        pre_node->next = new_node;  // 更新前一个节点的下一个指针
        cur_node->lock.unlock();  // 解锁当前节点
        pre_node->lock.unlock();  // 解锁前一个节点
        ebr_mgr_.FreeObject(cur_node);  // 释放旧节点
        return 0;  // 返回成功
      }
      auto *next_node = cur_node->next;  // 获取下一个节点
      pre_node->lock.unlock();  // 解锁前一个节点
      pre_node = cur_node;  // 更新前一个节点指针
      cur_node = next_node;  // 移动到下一个节点
    }
    pre_node->lock.unlock();  // 解锁最后一个节点
    return 1;  // 返回失败
  }

 private:
  Node *root_;  // 根节点指针
  EbrManager<Node, NodeFree, 15> ebr_mgr_;  // EBR 管理器
};

// 定义基准测试类
class MyBenchmark : public benchmark::Fixture {
 public:
  void SetUp(const ::benchmark::State &state) override {}  // 设置基准测试

  MyList &GetMyList() { return l; }  // 获取 MyList 实例

 private:
  MyList l;  // MyList 实例
  std::once_flag flag;  // 一次性标志
};

constexpr int kKeySize = 10000;  // 定义键值大小

// 定义不使用 EBR 的多线程工作基准测试
BENCHMARK_DEFINE_F(MyBenchmark, MultiThreadedWorkNoUseEbr)(benchmark::State &state) {
  for (auto _ : state) {
    auto &mylist = GetMyList();  // 获取 MyList 实例
    if (0 == state.thread_index()) {  // 主线程
      // 修改操作
      for (int i = 0; i < kKeySize; i++) {
        mylist.Modify(i % 9, i);  // 修改节点值
      }
    } else {  // 其他线程
      // 获取操作
      for (int i = 0; i < kKeySize; i++) {
        int value;
        mylist.Get(i % 9, &value);  // 获取节点值
      }
    }
  }
}

// 定义使用 EBR 的多线程工作基准测试
BENCHMARK_DEFINE_F(MyBenchmark, MultiThreadedWorkUseEbr)(benchmark::State &state) {
  for (auto _ : state) {
    auto &mylist = GetMyList();  // 获取 MyList 实例
    if (0 == state.thread_index()) {  // 主线程
      // 修改操作
      for (int i = 0; i < kKeySize; i++) {
        mylist.ModifyUseEbr(i % 9, i);  // 修改节点值
      }
    } else {  // 其他线程
      // 获取操作
      for (int i = 0; i < kKeySize; i++) {
        int value;
        mylist.GetUseEbr(i % 9, &value);  // 获取节点值
      }
    }
  }
}

// 注册基准测试，并指定线程数
BENCHMARK_REGISTER_F(MyBenchmark, MultiThreadedWorkNoUseEbr)->Threads(4);
BENCHMARK_REGISTER_F(MyBenchmark, MultiThreadedWorkNoUseEbr)->Threads(8);
BENCHMARK_REGISTER_F(MyBenchmark, MultiThreadedWorkNoUseEbr)->Threads(12);

BENCHMARK_REGISTER_F(MyBenchmark, MultiThreadedWorkUseEbr)->Threads(4);
BENCHMARK_REGISTER_F(MyBenchmark, MultiThreadedWorkUseEbr)->Threads(8);
BENCHMARK_REGISTER_F(MyBenchmark, MultiThreadedWorkUseEbr)->Threads(12);

BENCHMARK_MAIN();  // 运行基准测试

代码解释

  1. Node 结构体：

    • 定义了一个链表节点，包含键值、值、下一个节点指针和自旋锁。

  2. NodeFree 类：

    • 用于自动删除节点，构造函数中调用 delete 释放节点内存。

  3. MyList 类：

    • 实现了一个简单的链表，支持 Get 和 Modify 操作。
    • Get 和 Modify 方法使用自旋锁来保护节点。
    • GetUseEbr 和 ModifyUseEbr 方法使用 EBR 技术来管理内存回收。

  4. MyBenchmark 类：

    • 继承自 benchmark::Fixture，用于定义基准测试。
    • GetMyList 方法返回 MyList 实例。

  5. 基准测试定义：

    • MultiThreadedWorkNoUseEbr 和 MultiThreadedWorkUseEbr 分别定义了不使用 EBR 和使用 EBR 的多线程基准测试。
    • 主线程执行 Modify 操作，其他线程执行 Get 操作。

  6. 基准测试注册：

    • 使用 BENCHMARK_REGISTER_F 注册基准测试，并指定不同线程数。

  7. 运行基准测试：

    • BENCHMARK_MAIN 运行所有注册的基准测试。

通过这些注释，你应该能够更好地理解代码的结构和功能。如果有任何具体问题或需要进一步的帮助，请随时告知。

相关推荐
Prejudices10 分钟前
C++如何调用Python脚本
开发语言·c++·python
单音GG13 分钟前
推荐一个基于协程的C++(lua)游戏服务器
服务器·c++·游戏·lua
qing_04060329 分钟前
C++——多态
开发语言·c++·多态
孙同学_29 分钟前
【C++】—掌握STL vector 类：“Vector简介：动态数组的高效应用”
开发语言·c++
charlie1145141911 小时前
Qt Event事件系统小探2
c++·qt·拖放·事件系统
iiiiiankor1 小时前
C/C++内存管理 | new的机制 | 重载自己的operator new
java·c语言·c++
小辛学西嘎嘎1 小时前
C/C++精品项目之图床共享云存储（3）：网络缓冲区类和main
c语言·开发语言·c++
韭菜盖饭1 小时前
LeetCode每日一题3261---统计满足 K 约束的子字符串数量 II
数据结构·算法·leetcode
♡喜欢做梦1 小时前
【数据结构】ArrayList与LinkedList详解！！！——Java
java·开发语言·数据结构·链表
c语言鹌鹑蛋2 小时前
C++初阶 --- 类和对象（1）
开发语言·c++
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04VSCode插件 —— Cody AI （免费AI助手！）05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO08文件或文件夹名称中有空格如何批量去除09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【QuikGraph】C#调用第三方库实现迪杰斯特拉(Dijkstra)算法功能