LevelDB源码分析6-skip_list

最新推荐文章于 2024-01-19 21:38:16 发布
最新推荐文章于 2024-01-19 21:38:16 发布
阅读量521 收藏 1
点赞数
分类专栏： leveldb源码学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/charles1e/article/details/53202278
版权

leveldb在内存中的数据为memtable(也有immuable memtable，只读)，在底层用skiplist来实现。skiplist平均查找时间为O(logN)，最坏为O(N)，实现简单，常数项小。lerveldb采用内存屏障来实现同步，支持多线程操作。

内存屏障[1]

内存屏障用于进程组的同步，在应用中划分了若干个阶段，并且规定只有所有的进程都就需准备到下一个阶段，进程才可以进入下一个阶段。可以通过在每个阶段的结尾安置屏障来实现，当任何一个进程到达屏障时，只能等待，直到所有进程都达到该屏障为止。

内存屏障主要解决了两个问题：单处理器下的乱序问题和多处理器下的内存同步问题。

为什么会乱序

现代CPU用流水线来执行指令，一个指令的执行被分成：取指、译码、访存、执行、写回、等若干个阶段。为了防止一个指令在“执行”阶段呆很长时间，导致后续指令都卡在“执行之前”的阶段，流水线都是并行执行，多条指令可以处于同一执行阶段。这样就容易乱序。比如一条加法指令原本出现在一条除法指令的后面，但是由于除法的执行时间很长，在它执行完之前，加法可能先执行完了。再比如两条访存指令，可能由于第二条指令命中了cache而导致它先于第一条指令完成。
CPU的乱序执行并不是任意的乱序，而是以保证程序上下文因果关系为前提的。有了这个前提，CPU执行的正确性才有保证。比如：

a++; 
b=f(a); 
c--;

由 于b=f(a)这条指令依赖于前一条指令a++的执行结果，所以b=f(a)将在“执行”阶段之前被阻塞，直到a++的执行结果被生成出来；而c–跟前 面没有依赖，它可能在b=f(a)之前就能执行完。（注意，这里的f(a)并不代表一个以a为参数的函数调用，而是代表以a为操作数的指令。C语言的函数 调用是需要若干条指令才能实现的，情况要更复杂些。）

像 这样有依赖关系的指令如果挨得很近，后一条指令必定会因为等待前一条执行的结果，而在流水线中阻塞很久，占用流水线的资源。而编译器的乱序，作为编译优化 的一种手段，则试图通过指令重排将这样的两条指令拉开距离, 以至于后一条指令进入CPU的时候，前一条指令结果已经得到了，那么也就不再需要阻塞等待了。比如将指令重排为：
a++; c–; b=f(a);
相比于CPU的乱序，编译器的乱序才是真正对指令顺序做了调整。但是编译器的乱序也必须保证程序上下文的因果关系不发生改变。

乱序的后果

乱序执行，有了“保证上下文因果关系”这一前提，一般情况下是不会有问题的。因此，在绝大多数情况下，我们写程序都不会去考虑乱序所带来的影响。
但是，有些程序逻辑，单纯从上下文是看不出它们的因果关系的。比如：

*addr=5; val=*data;

从 表面上看，addr和data是没有什么联系的，完全可以放心的去乱序执行。但是如果这是在某某设备驱动程序中，这两个变量却可能对应到设备的地址端口和 数据端口。并且，这个设备规定了，当你需要读写设备上的某个寄存器时，先将寄存器编号设置到地址端口，然后就可以通过对数据端口的读写而操作到对应的寄存 器。那么这么一来，对前面那两条指令的乱序执行就可能造成错误。
对于这样的逻辑，我们姑且将其称作隐式的因果关系；而指令与指令之间直接的输入输出依赖，也姑且称作显式的因果关系。CPU或者编译器的乱序是以保持显式的因果关系不变为前提的，但是它们都无法识别隐式的因果关系。再举个例子：

obj->data = xxx; obj->ready = 1;

当设置了data之后，记下标志，然后在另一个线程中可能执行：

if (obj->ready) do_something(obj->data);

虽然这个代码看上去有些别扭，但是似乎没错。不过，考虑到乱序，如果标志被置位先于data被设置，那么结果很可能就杯具了。因为从字面上看，前面的那两条指令其实并不存在显式的因果关系，乱序是有可能发生的。

总的来说，如果程序具有显式的因果关系的话，乱序一定会尊重这些关系；否则，乱序就可能打破程序原有的逻辑。这时候，就需要使用屏障来抑制乱序，以维持程序所期望的逻辑。

屏障的作用

内存屏障主要有：读屏障、写屏障、通用屏障、优化屏障、几种。
以 读屏障为例，它用于保证读操作有序。屏障之前的读操作一定会先于屏障之后的读操作完成，写操作不受影响，同属于屏障的某一侧的读操作也不受影响。类似的， 写屏障用于限制写操作。而通用屏障则对读写操作都有作用。而优化屏障则用于限制编译器的指令重排，不区分读写。前三种屏障都隐含了优化屏障的功能。比如：

tmp = ttt; *addr = 5; mb(); val = *data;

有了内存屏障就了确保先设置地址端口，再读数据端口。而至于设置地址端口与tmp的赋值孰先孰后，屏障则不做干预。

有了内存屏障，就可以在隐式因果关系的场景中，保证因果关系逻辑正确。

多处理器情况

前面只是考虑了单处理器指令乱序的问题，而在多处理器下，除了每个处理器要独自面对上面讨论的问题之外，当处理器之间存在交互的时候，同样要面对乱序的问题。
一 个处理器（记为a）对内存的写操作并不是直接就在内存上生效的，而是要先经过自身的cache。另一个处理器（记为b）如果要读取相应内存上的新值，先得 等a的cache同步到内存，然后b的cache再从内存同步这个新值。而如果需要同步的值不止一个的话，就会存在顺序问题。再举前面的一个例子：

  obj->data = xxx;
  wmb();               if (obj->ready)
  obj->ready = 1;          do_something(obj->data);

前面也说过，必须要使用屏障来保证CPU-a不发生乱序，从而使得ready标记置位的时候，data一定是有效的。但是在多处理器情况下，这还不够。data和ready标记的新值可能以相反的顺序更新到CPU-b上！
其实这种情况在大多数体系结构下并不会发生，不过内核文档memory-barriers.txt举了alpha机器的例子。alpha机器可能使用分列的cache结构，每个cache列可以并行工作，以提升效率。而每个cache列上面缓存的数据是互斥的（如果不互斥就还得解决cache列之间的一致性），于是就可能引发cache更新不同步的问题。
假设cache被分成两列，而CPU-a和CPU-b上的data和ready都分别被缓存在不同的cache列上。
首 先是CPU-a更新了cache之后，会发送消息让其他CPU的cache来同步新的值，对于data和ready的更新消息是需要按顺序发出的。如果 cache只有一列，那么指令执行的顺序就决定了操作cache的顺序，也就决定了cache更新消息发出的顺序。但是现在假设了有两个cache列，可 能由于缓存data的cache列比较繁忙而使得data的更新消息晚于ready发出，那么程序逻辑就没法保证了。不过好在SMP下的内存屏障在解决指 令乱序问题之外，也将cache更新消息乱序的问题解决了。只要使用了屏障，就能保证屏障之前的cache更新消息先于屏障之后的消息被发出。
然 后就是CPU-b的问题。在使用了屏障之后，CPU-a已经保证data的更新消息先发出了，那么CPU-b也会先收到data的更新消息。不过同 样，CPU-b上缓存data的cache列可能比较繁忙，导致对data的更新晚于对ready的更新。这里同样会出问题。
所以，在这种情况下，CPU-b也得使用屏障。CPU-a上要使用写屏障，保证两个写操作不乱序，并且相应的两个cache更新消息不乱序。CPU-b上则需要使用读屏障，保证对两个cache单元的同步不乱序。可见，SMP下的内存屏障一定是需要配对使用的。
所以，上面的例子应该改写成：

  obj->data = xxx;     if (obj->ready)
  wmb();                   rmb();
  obj->ready = 1;          do_something(obj->data);

CPU-b上使用的读屏障还有一种弱化版本，它不保证读操作的有序性，叫做数据依赖屏障。顾名思义，它是在具有数据依赖情况下使用的屏障，因为有数据依赖（也就是之前所说的显式的因果关系），所以CPU和编译器已经能够保证指令的顺序。
再举个例子：


  init(newval);        p = data;
  data = &newval;      val = *p;

这里的屏障就可以保证：如果data指向了newval，那么newval一定是初始化过的。

LevelDB中的memorybarrier

可以看到MemoryBarrier()实际上就是如下的一条汇编语句：

  • __asm__ __volatile__(“” : : : “memory”);
  • __asm__用于指示编译器在此插入汇编语句
  • __volatile__用于告诉编译器，严禁将此处的汇编语句与其它的语句重组合优化。即：原原本本按原来的样子处理这这里的汇编。
  • memory 强制gcc编译器假设RAM所有内存单元均被汇编指令修改，这样cpu中的registers和cache中已缓存的内存单元中的数据将作废。cpu将不 得不在需要的时候重新读取内存中的数据。这就阻止了cpu又将registers，cache中的数据用于去优化指令，而避免去访问内存。
  • “”:::表示这是个空指令。

skiplist节点

skiplist的节点有一个key和一个指针数组，指向后面的节点。

// Implementation details follow
//skiplist的节点
template<typename Key, class Comparator>
struct SkipList<Key,Comparator>::Node {
  explicit Node(const Key& k) : key(k) { }

  Key const key;

  // Accessors/mutators for links.  Wrapped in methods so we can
  // add the appropriate barriers as necessary.
  //获取指针数组指向的第n个的节点
  Node* Next(int n) {
    assert(n >= 0);
    // Use an 'acquire load' so that we observe a fully initialized
    // version of the returned Node.
    return reinterpret_cast<Node*>(next_[n].Acquire_Load());
  }
  //将node x设置为该节点指向的第n个节点
  void SetNext(int n, Node* x) {
    assert(n >= 0);
    // Use a 'release store' so that anybody who reads through this
    // pointer observes a fully initialized version of the inserted node.
    next_[n].Release_Store(x);
  }

  // No-barrier variants that can be safely used in a few locations.
  Node* NoBarrier_Next(int n) {
    assert(n >= 0);
    return reinterpret_cast<Node*>(next_[n].NoBarrier_Load());
  }
  void NoBarrier_SetNext(int n, Node* x) {
    assert(n >= 0);
    next_[n].NoBarrier_Store(x);
  }

 private:
  // Array of length equal to the node height.  next_[0] is lowest level link.
  port::AtomicPointer next_[1];
};

skiplist

template<typename Key, class Comparator>
class SkipList {
 private:
  struct Node;      //节点
 public:
  explicit SkipList(Comparator cmp, Arena* arena);
  void Insert(const Key& key);
  bool Contains(const Key& key) const;

  // Iteration over the contents of a skip list
  class Iterator {
   public:

    explicit Iterator(const SkipList* list);
    bool Valid() const;
    const Key& key() const;
    void Next();
    void Prev();
    void Seek(const Key& target);
    void SeekToFirst();
    void SeekToLast();

   private:
    const SkipList* list_;      //skiplist
    Node* node_;                //指向的当前节点
  };

 private:
  enum { kMaxHeight = 12 };     //允许最大高度
  Arena* const arena_;    // 用于申请节点内存
  Node* const head_;    //头结点
  port::AtomicPointer max_height_;   // 当前最大高度
  inline int GetMaxHeight() const {
    return reinterpret_cast<intptr_t>(max_height_.NoBarrier_Load());
  }
  Random rnd_;          //随机类，用于插入操作
  Node* NewNode(const Key& key, int height);
  int RandomHeight();
  bool Equal(const Key& a, const Key& b) const { return (compare_(a, b) == 0); }

  bool KeyIsAfterNode(const Key& key, Node* n) const;
  Node* FindGreaterOrEqual(const Key& key, Node** prev) const;
  Node* FindLessThan(const Key& key) const;
  Node* FindLast() const;
  SkipList(const SkipList&);
  void operator=(const SkipList&);
};

leveldb的skiplist定义跳跃表的最大高度为12。
内部成员有：比较器(cmpare_)，内存池(arena_)，指向头结点的指针(head_)和最大的高度(max_height_)，随机数类(rnd_)

创建节点

//创建一个新节点
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node*
SkipList<Key,Comparator>::NewNode(const Key& key, int height) {
//从内存池申请空间，用于存储新节点
  char* mem = arena_->AllocateAligned(
      sizeof(Node) + sizeof(port::AtomicPointer) * (height - 1));
  return new (mem) Node(key);   //在申请的men空间执行Node的构造函数
}

其他的一些函数

//迭代器的构造函数，初始化时，不指向任何节点
template<typename Key, class Comparator>
inline SkipList<Key,Comparator>::Iterator::Iterator(const SkipList* list) {
  list_ = list;
  node_ = NULL;
}
//判断是否有效，如果节点不为空，则有效
template<typename Key, class Comparator>
inline bool SkipList<Key,Comparator>::Iterator::Valid() const {
  return node_ != NULL;
}
//返回迭代器的值key
template<typename Key, class Comparator>
inline const Key& SkipList<Key,Comparator>::Iterator::key() const {
  assert(Valid());
  return node_->key;
}
//下一个节点，Next(0)即可
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::Next() {
  assert(Valid());
  node_ = node_->Next(0);
}
//上一个节点
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::Prev() {
  // Instead of using explicit "prev" links, we just search for the
  // last node that falls before key.
  assert(Valid());
  node_ = list_->FindLessThan(node_->key);//先找到比key小的节点
  if (node_ == list_->head_) {
    node_ = NULL;
  }
}


template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::Seek(const Key& target) {
  node_ = list_->FindGreaterOrEqual(target, NULL);
}

template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::SeekToFirst() {
  node_ = list_->head_->Next(0);
}

template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::SeekToLast() {
  node_ = list_->FindLast();
  if (node_ == list_->head_) {
    node_ = NULL;
  }
}

//产生随机的高度
template<typename Key, class Comparator>
int SkipList<Key,Comparator>::RandomHeight() {
  // Increase height with probability 1 in kBranching
  static const unsigned int kBranching = 4;
  int height = 1;
  while (height < kMaxHeight && ((rnd_.Next() % kBranching) == 0)) {
    height++;
  }
  assert(height > 0);
  assert(height <= kMaxHeight);
  return height;
}

//key所在的是否在n节点的后面，是返回真，否则返回假
template<typename Key, class Comparator>
bool SkipList<Key,Comparator>::KeyIsAfterNode(const Key& key, Node* n) const {
  // NULL n is considered infinite
    //n不能为空，n->key<key
  return (n != NULL) && (compare_(n->key, key) < 0);
}

//查找大于等于key的节点
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node* SkipList<Key,Comparator>::FindGreaterOrEqual(const Key& key, Node** prev)
    const {
  Node* x = head_;
  int level = GetMaxHeight() - 1;   //从最高层次开始找
  while (true) {
    Node* next = x->Next(level);
    if (KeyIsAfterNode(key, next)) {//如果key所在节点在next后，那么继续在这条链表上查找。
      // Keep searching in this list
      x = next; //x指向下一个节点
    } else {//如果不是在next后面
      if (prev != NULL) prev[level] = x;
      if (level == 0) {
        return next;    //如果到了最下层，返回
      } else {
        // Switch to next list
        level--;
      }
    }
  }
}

//查找比key小的节点
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node*
SkipList<Key,Comparator>::FindLessThan(const Key& key) const {
  Node* x = head_;                      //初始化为头结点
  int level = GetMaxHeight() - 1;       //高度为最大高度-1
  while (true) 
  {
    assert(x == head_ || compare_(x->key, key) < 0);
    Node* next = x->Next(level);
    if (next == NULL || compare_(next->key, key) >= 0) //如果后继节点为空或者next->key>=key的话，说明这一层没有找到
    {
      if (level == 0) //第0层，直接返回x,第一个比key小的，后面都比key大了
      {
        return x;
      } 
      else 
      {
        // Switch to next list //不是第0层，继续降低level比较
        level--;
      }
    } 
    else //不为空而且next->key < key,说明可以在这一层继续查找
    {
      x = next; //x现在指向下一个节点
    }
  }
}

template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node* SkipList<Key,Comparator>::FindLast()
    const {
  Node* x = head_;
  int level = GetMaxHeight() - 1;
  while (true) {
    Node* next = x->Next(level);
    if (next == NULL) {
      if (level == 0) {
        return x;
      } else {
        // Switch to next list
        level--;
      }
    } else {
      x = next;
    }
  }
}


//skiplist构造函数
//传入cmp和arena,头结点key初始化为0，高度为最大高度，max_height_初始化为1
//随机初始化为0xdeadbeef,将头结点的后继都设为NULL
template<typename Key, class Comparator>
SkipList<Key,Comparator>::SkipList(Comparator cmp, Arena* arena)
    : compare_(cmp),
      arena_(arena),
      head_(NewNode(0 /* any key will do */, kMaxHeight)),
      max_height_(reinterpret_cast<void*>(1)),
      rnd_(0xdeadbeef) {
  for (int i = 0; i < kMaxHeight; i++) {
    head_->SetNext(i, NULL);
  }
}

//插入新节点
//
template<typename Key, class Comparator>
void SkipList<Key,Comparator>::Insert(const Key& key) {
  // TODO(opt): We can use a barrier-free variant of FindGreaterOrEqual()
  // here since Insert() is externally synchronized.
  Node* prev[kMaxHeight];
  Node* x = FindGreaterOrEqual(key, prev);

  // Our data structure does not allow duplicate insertion
  assert(x == NULL || !Equal(key, x->key));

  int height = RandomHeight();
  if (height > GetMaxHeight()) {
    for (int i = GetMaxHeight(); i < height; i++) {
      prev[i] = head_;
    }
    //fprintf(stderr, "Change height from %d to %d\n", max_height_, height);

    // It is ok to mutate max_height_ without any synchronization
    // with concurrent readers.  A concurrent reader that observes
    // the new value of max_height_ will see either the old value of
    // new level pointers from head_ (NULL), or a new value set in
    // the loop below.  In the former case the reader will
    // immediately drop to the next level since NULL sorts after all
    // keys.  In the latter case the reader will use the new node.
    max_height_.NoBarrier_Store(reinterpret_cast<void*>(height));
  }

  x = NewNode(key, height);
  for (int i = 0; i < height; i++) {
    // NoBarrier_SetNext() suffices since we will add a barrier when
    // we publish a pointer to "x" in prev[i].
    x->NoBarrier_SetNext(i, prev[i]->NoBarrier_Next(i));
    prev[i]->SetNext(i, x);
  }
}

//是否包含key的节点
template<typename Key, class Comparator>
bool SkipList<Key,Comparator>::Contains(const Key& key) const {
  Node* x = FindGreaterOrEqual(key, NULL);
  if (x != NULL && Equal(key, x->key)) {
    return true;
  } else {
    return false;
  }
}

}

参考

[1]http://ifeve.com/memory-barriers-or-fences/

延禾xy
关注
专栏目录
linux内核中的内存屏障
qb_2008的专栏
10-02 4589
前言        之前读了关于顺序一致性和缓存一致性讨论的文章，感觉豁然开朗。对linux内核中出现的种种同步和屏障，想做一点总结。 缓存一致性        之前一直认为linux中很多东西是用来保证缓存一致性的，其实不是。缓存一致性绝大部分是靠硬件机制实现的，
Leveldb源码分析--1
热门推荐
sparkliang的专栏
02-05 5万+
【前言：看了一点oceanbase，没有意志力继续坚持下去了，暂时就此中断，基本上算把master看完了，比较重要的update server和merge server代码却没有细看。中间又陆续研究了hadoop的源码，主要是name node和写入pipeline。主要的目的是想看看name node对namespace的管理，以及hadoop在写入操作时，client、data nod
linux内存屏障浅析
张勤一
08-22 2011
内存屏障主要解决了两个问题：单处理器下的乱序问题和多处理器下的内存同步问题。为什么会乱序现在的CPU一般采用流水线来执行指令。一个指令的执行被分成：取指、译码、访存、执行、写回、等若干个阶段。然后，多条指令可以同时存在于流水线中，同时被执行。指令流水线并不是串行的，并不会因为一个耗时很长的指令在“执行”阶段呆很长时间，而导致后续的指令都卡在“执行”之前的阶段上。相反，流水线是并行的，多个指令可以同
Linux内核中的内存屏障(1)
permike的专栏
11-27 826
本文内容遵从CC版权协议,转载请注明出自larmbr.me 概览 SMP这种并行架构相比传统的单处理器带来相当可观的性能提升。一个不可避免的问题是并行架构的处理器间的交互问题。一种可能的解决方案是，每个CPU都有自己唯一可访问内存，处理器间通过消息传递进行通信。这种架构的问题是带给程序员(尤其是系统程序员)巨大的编程负担，因为需要处理数据分隔与传递。相反，被广泛应用的另一种架构是，
leveldb_chinese_comments-Code_analysis_cld378632668.tar.gz
10-20
《图解leveldb源码和中文注释》是一份深度剖析开源数据库系统leveldb的资源，其中包含了详尽的代码分析和中文注释，旨在帮助开发者更好地理解和应用这个高性能、轻量级的键值存储系统。leveldb由Google开发，广泛...
lrucacheleetcode-learn_leveldb:leveldb源码注释
06-29
在LevelDB里面为了防止skiplist大量多次内存分配导致的碎片，采用了自己写的一套内存分配管理器。名称为Arena。 但是需要注意的是，这个内存分配器并不是为整个LevelDB项目考虑的。主要是为skiplist也就是memtable...
深入剖析Leveldb源码：Log-Structured Merge Tree实现
"leveldb源码分析，lleveldb，分布式系统，Linux，数据库，存储引擎，skiplist，内存管理，LRU缓存，table文件，operationlog" Leveldb是一款由Google开发的轻量级、高性能的单机键值存储系统，其源码设计简洁且...
Leveldb源码分析--3
sparkliang的专栏
02-23 1万+
4 Memtable之1 Memtable是leveldb很重要的一块，leveldb的核心之一。我们肯定关注KV数据在Memtable中是如何组织的，秘密在Skip list中。 4.1 用途 在Leveldb中，所有内存中的KV数据都存储在Memtable中，物理disk则存储在SSTable中。在系统运行过程中，如果Memtable中的数据占用内存到达指定值(Optio
Linux内存屏障
11-17
Linux内存屏障，CSDN 2015开发者大会上的优秀演讲
中国Linux内核开发者大会十周年演讲稿（中兴通讯谢宝友）-Linux内存屏障
10-25
中国Linux内核开发者大会十周年演讲稿（中兴通讯谢宝友）-Linux内存屏障
linux内存屏障
m0_46392035的博客
01-25 722
它的开销是四种屏障中最大的。在大多数处理器的实现中，这个屏障是个万能屏障，兼具其它三种内存屏障的功能。在每个volatile写操作前插入StoreStore屏障，在写操作后插入StoreLoad屏障；在每个volatile读操作前插入LoadLoad屏障，在读操作后插入LoadStore屏障；
【Linux】内存屏障
lyk82698的博客
11-23 668
【Linux】内存屏障
linux 内存屏障,理解内存屏障（一）
weixin_34611130的博客
05-01 357
作者：新浪微博()计算机学习微信公众号(jsj_xx)1 前言内存屏障是搞软件的需要面对的一个涉及硬件cpu的问题，很多人困惑不解。本文是我们对linux内核内存屏障的理解，参考linux内核(4.0版本)的Documentation/memory-barriers.txt。2 内容主要内容如下：2.1 内存访问的的抽象模型2.2 什么是内存屏障2.3 内核中的显式和隐式的内存屏障2.4 cpu间...
【Linux 内核源码分析】内存屏障
最新发布
C/C++Linux、音视频、DPDK
01-19 1514
smp_store_mb()和smp_load_acquire()分别是带屏障的存储和加载函数，用于确保存储和加载操作的顺序和一致性。内存屏障的作用是强制对内存的访问顺序进行排序，保证多线程或多核处理器下的内存访问的一致性和可见性。在这种模型下，程序无法依赖于全局的、确定性的操作执行顺序。这些序列关系的正确性和顺序一致性是通过硬件层面的内存屏障指令、缓存一致性协议和处理器乱序执行的机制来实现的。Linux内核提供了多种内存屏障，包括通用的内存屏障、数据依赖屏障、写屏障、读屏障、释放操作和获取操作等。
linux 内存屏障
ldinvicible的专栏
11-19 99
如果在程序某处插入了mb()/rmb()/wmb()宏，则宏之前的程序保证比宏之后的程序先执行，从而实现串行化 rmb()不允许读操作穿过内存屏障；wmb()不允许写操作穿过屏障；而mb()二者都不允许。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值