memory consistency

目前的计算机系统中,都是shared memory结构,提供统一的控制接口给软件,

shared memory结构中,为了memory correctness,可以将问题分为:memory consistency,和memory coherency

为了memory consistency的正确性,是需要program的编写者的操作,主要描述对一块memory的不同的load,store之间的顺序

而memory coherency,则对software是完全透明的,主要为了多cache在系统中的表现像单cache一样。

memory consistency实现之后,coherency一定是保证的,但是coherency保证之后,consistency不一定可以保证。

 

为了避免memory consistency,需要保证对同一address的,多个core或者多个线程store/load都是 in-ordered,为不同的address,无所谓的。

  发生memory consistency,可能是store-store,load-load,load-store。store-load之间的out-of order。

 

memory consistency model是一个系统性的问题,会直接影响程序(多线程,多进程)编写

  涉及到,processor的设计,memory system的设计,interconnect的设计,

      compiler的优化,programming language的使用。

关于consistency model最简单的描述是,读操作需要返回最新写入memory的值

 

memory reorder只有在软件实现lock-free 编程的时候,才可能影响运算结果

memory ordering模型,是并发程序设计的基础。主要的内容:

1) atomic VS reorder

  与cpu bus总线对齐的read/write,都是atomic的,如果非对齐,比如32bit的bus总线,访问64bit的数据,

    映射到str,ldr会变为两条指令在单核多线程和多核的运行环境下,可能会出现half-read,half-write

    情况。

  RMW,read-modified-write,都是非atomic的

 

  为此很多的微处理器,提出了atomic的指令,一条指令实现较复杂的功能,从而实现atomic性;

    CMPXCHG(compare-and-exchange),XCHG等。这些atomic指令,只能保证单核多线程的原子性,在多核情况下,还是需要加lock

 

  reorder,的主要考虑是performance,在BP失败或者cache miss的时候,都需要reorder,主要是STR或者LDR指令的乱序

      reorder的原则是硬件隐藏细节,使得数据的load,store,按single thread的顺序正确执行

  reorder的类型包括,

      Compiler Reordering,程序编译期间,

        Barrier指令保证前后的语句不会被reorder。

        compiler memory barrier instruction:GNU编译器,asm volatile("":::"memory")

                               __asm__ __volatile(""::::"memory")

                         intel ecc compiler

                               __memory_barrier()

                         Microsoft Visual C++

                               ——ReadWriteBarrier() 

        CPU并感知不到compiler memory barrier的存在,而且实现compiler的memory barrier之后,

          reorder还是可能在CPU memory reorder中发生的。

      CPU memory Ordering,程序执行期间:memory reorder,特指processor通过load,store指令,

          system bus访问system memory期间的乱序

          memory reorder的类型可以分为四类:

                LoadLoad,

                LoadStore,

                StoreLoad,

                StoreStore,

          CPU  memory order的实现,对软件来说,是透明的。 

      CPU会进行reorder的原因 ,可能是指令的BP失败,cache miss等,先将load,store放在load buffer,store buffer,invalid buffer中

2) Memory Barrier

  cpu的memory barrier,相比较于compiler来说,是一条真正的指令,针对四种memory reorder,目前有四种memory barrier的类型:

    LoadLoad Barrier

    LoadStore Barrier

    StoreLoad Barrier

    StoreStore Barrier

  具体的barrier指令有三种:

    Store Barrier(Write Barrier),Store Barrier前后的store操作,必须是按顺序执行的,对load没有影响。

    Load Barrier(Read Barrier),Load Barrier前后的load操作,必须是按顺序执行的,对write没有影响。

    Full Barrier(Load+Store Barrier),Full Barrier两边的任何操作,均不可以交换顺序。

    

 

CPU的memory model根据processor,tool chain的不同,有很多的选择。

  主要的CPU memory models:

    Programming Order------------------Strong Memory Model

    Sequential Consistency(SC模型)

    Strict Consistency

    Data Dependency Order------------Weaker Memory Model

  

 

强弱内存模型的主要区别点:但一个CPU核执行一连串的写操作时,其他的CPU核看到这些值的改变顺序是否与其顺序一致

  目前很难找到一个在硬件层面保证SC模型,所以当用上语言编程时,SC为成为一个重要的软件内存模型,

  Java5之后,用violation声明共享变量,

  C++11中,使用默认的顺序约束memory_order_seq_cst,做原子操作,

  使用这些技术之后,编译器会限制编译乱序,并且插入特定CPU的memory barrier指令,来保证原子操作

 

最具典型的consistency model被称为SC (sequential consistency)。

sequential model在实现中的architecture:

1)系统中不带cache的SC model,如果是多核,需要自己实现一个switch:

   

2)系统中带有cache:多核情况下,cache coherence protocol充当了switch的角色,可以看做一个黑盒:

    

 

总结:

load-load、store-store,是必须按program order来的

load-store、store-load,是必须按program order来的

sequential consistency必须保证:1)program order,processor必须保证前一memory访问结束,才能开始新的memory访问;

                  在cache的系统中,必须保证所有的cache都被invalid或者update,收到相应的ack信号。  

               2)write atomicity,对同一地址的写操作,必须是serialized,同样必须是收到invalid和update的ack信号。

    这些要求,针对任何load-store对。

SC Ordering Rule总结,表示的是单核的要求,RMW表示原子操作。

    

在硬件优化与SC模型中会出现的问题:

  1) 没有cache的情况下,

    1.带write buffer的结构,read bypass的操作下,后边的读操作可能会越过写操作。

    2.重叠写,overlapping write,多个不同地址的同时写,后边的写操作,较前边的写操作,先完成。

    3.非阻塞读,nonblocking reads,多个不同地址的同时读,后边的读操作,较前边的读操作,先完成。

  2) 有cache的情况下,

    1.必须实现cache coherency协议。

    2.检查写的ack信号。一个core必须等到另一个core的写ack信号之后,再发送下一个写操作。

    3.保证write atomicity,cache的本质是将一个值的改变,传播给多个处理器的缓存,本身是非原子性的,所以有两个要求;

      1.针对同一地址的写操作被串行化(serialized)

       2.对一个新写的值的读操作,必须是所有其他的core,都返回ack的情况。

  与特定的硬件优化结合起来的时候,SC模型的保证是有代价的。

 

其他的memory model,较SC,有两方面的改变:

  1) 放松对程序次序的要求,只适用于不同地址的load,store操作;

  2) 放松对原子性的要求,一些模型允许读操作在“一个写操作未对所有处理器可见的情况下”执行。只适用于有buffer的体系结构。

 

X86多使用的是一种称为TSO(Total Store Order)的memory consistency model, 与SC model相比较。放开了store-load的顺序要求

  只是放开了程序次序中的这一小部分

  TSO中,每个processor都加入了一个write buffer,所以可以memory order上来看store比load晚,但是指令上仍然是load先执行的

    类似于cache中的write-back的policy。

    

TSO model的实现:

    

  如果programmer要求,store-load必须按顺序执行,则需要在store之后,加入fence命令。

    fence命令只能挡住本processor的执行,对其他的processor起不到作用

    但是原子操作可以,用exclusive的访问,其他的processor访问不到该数据

TSO Ordering Rules要求,针对单核的情况:

    

 

Relaxed memory models:

relaxed model既有对program order方面的优化也有write atomicity方面的优化

ARM和PowerPC,多使用relax model,一个example model,XC model,

XC model的ordering Rule,单核情况:

    

XCmodel的实现:

    

 

程序设计时的memory相关的指令:

1) violatile,变量修饰词,表示cpu不会每次都从cache中拿值,而是每次都必须访问main-memory。一般计算机中的外设相关的变量都

    需要设定为violatile,防止被compiler优化。但是并不能用于构建原子操作。

2) 原子操作,分为blocking和non-blocking两种,类似于AXI中的lock trans和exclusive trans。

3) 互斥锁,mutex,在多进程,多线程间使用,拿不到mutex时,进程或线程被休眠blocking

    底层使用lock transaction。

4) 自旋锁(spinlock),在等待共有资源有效的过程中,会一直等待,线程、进程不会被休眠non-blocking

5) semaphore,等待一定数量的共有资源,直接在程序中声明。blocking

    底层使用lock transaction。

6) read-modify-write,使用strex或者ldrex汇编指令,对读改写进行包装。non-blocking

7) compare-and-swap,等同于LL(load-link)、SC(store-conditional)指令,底层也是调用strex和ldrex指令,non-blocking

8) 其他的atomic operation,test-and-set,fetch-and-add,compare-and-swap指令。

 

在exclusive trans设计中,会有两个monitor,一个local monitor(只是monitor该cpu,一般放在cpu core内),

    一个global monitor(monitor整个sys,一般放在主的interconnect中)

    

  bus trans的memory type如果是Non-Shareable的,此时的exclusive只检查local monitor,然后可能会直接返回Exok

               如果是Shareable的,此时的exclusive,会检查local monitor和global monitor,如果有violation,会直接返回Exok。

  在有cache的系统中,并且此时的memory type是cacheable的,exclusive的访问需要和local minitor,global monitor,SCU共同决定sync的结果。

 

这些model在实现中,都是依托于指令集来实现的,arm和intel都有提供相应的原子操作指令。

 

在程序代码编写的时候,也可以自己控制,通过memory fence命令,来保证多核多线程对共享变量的访问。

单核系统中,也会出现memory consistent的问题,因为目前的cpu都是超标量,多线程,乱序执行的,所以program order并不能

    反映到executed order。

 

之上是单核memory reorder的问题,之后写一些多核数据一致性的问题。

 

软件中数据的同步问题,

1.在单核多线程的情况下,可以通过disable所有中断,包括cpu内核调度,来达到目的,只在sync var被处理之后,再放开中断。

    这样可以达到sync的目的,但是在增加了interrupt的latency。

2.在多核多线程的情况下,需要保证多核之间的同步,arm增加了自己的指令,来锁住bus,v6架构之前是swp指令,v6架构之后是ldrex指令。

 

下边讨论一下指令加锁的应用:

 X86的很多指令,都可以在前边加lock,来保证原子性,加lock的指令,会保证对当前访问的内存的互斥性。

  在单核处理器系统中,能够在单条指令中完成的操作都可以被认为是原子操作。因为中断和线程切换都只能在指令与指令之间;

  但是在多核处理器中,由于多个core同时独立的运行,即使能单条指令就可以完成的操作,也会受到其他core的干扰,

    导致memory consistent出现问题,所以需要多核之间的同步。

X86的lock指令,做的便是多核之间访问同一memory的同步,类似的有arm中的strex和ldrex,

arm中的strex和ldrex,是armv6之后才引进来的,之前使用的是swp,swpb指令,等效于lock bus+memory swap。

  缺点有两点:

    1.但是直接锁死bus会导致,其他的core不能访问bus,性能受到影响,

    2.由于这个指令既有str又有ldr,多以执行时间会比较长,如果这时有中断,就必须等待这条指令执行结束,这样增加了中断的latency。

  所以无论是多核还是单核,swp指令都没有目前的ldrex和strex方便。

 

参考文档,Shared Memory Consistency Models A Tutorial.pdf

     a primer on memory consistency and coherence.pdf

     Weak vs. Strong Memory Models  网页

        浅谈Memory Reordering 网页  

     CPU cache and Memory Ordering 并发程序设计入门

     https://www.kernel.org/doc/Documentation/memory-barriers.txt

posted @ 2018-01-30 14:41  _9_8  阅读(1501)  评论(0编辑  收藏  举报