030-JVM-Cache Line、缓存对齐、伪共享

阳光穿透心脏的1/2处 2023-01-01 11:49 108阅读 0赞

[上一篇：029-JVM-volatil e和指令重排  
https://yuhongliang.blog.csdn.net/article/details/111997753][029-JVM-volatil e_ https_yuhongliang.blog.csdn.net_article_details_111997753]

# 1.存储器的层次就结构 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70]  
由于寄存器的速度是非常快的，是内存的100被，是硬盘的10的六次方倍。  
下图是个硬件的速度指标，可以使我们对其有更为直观的认识：

<table> 
 <thead> 
  <tr> 
   <th>从cpu到</th> 
   <th>大约需要cpu周期</th> 
   <th>大约小的时间</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>主存（内存）</td> 
   <td></td> 
   <td>60-80ns</td> 
  </tr> 
  <tr> 
   <td>QPI总线（between sockets ,ont drawn）</td> 
   <td></td> 
   <td>20ns</td> 
  </tr> 
  <tr> 
   <td>L3</td> 
   <td>45cycle</td> 
   <td>15ns</td> 
  </tr> 
  <tr> 
   <td>L2</td> 
   <td>10cycle</td> 
   <td>3ns</td> 
  </tr> 
  <tr> 
   <td>L1</td> 
   <td>3cycle</td> 
   <td>1ns</td> 
  </tr> 
  <tr> 
   <td>寄存器</td> 
   <td>1cycle</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

cpu读取数据，吸纳从寄存器中读取，如果无，则一次L1\\L2\\L3读取。

# 2.cache line 缓存行 #

那么系统读取数据是需要什么读取什么吗？当然是的，但是由于缓存行的存在，他会都去更多的数据。比如读取一个int类型4个字节的数据，他会把这四个字节后面的60个字节都读进去，即每次读64个字节的数据。这就是`缓存行cache line`

# 3.cache line 缓存行 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 1]  
场景：  
在多核cpu读取数据的时候：

*  core1 读取了x=1的数据，不好意思，由于cache line的存在，他需要把后面的y=2联通后面的数据一读进core1中；
 *  core2 读取了y=2的数据，不好意思，由于cache line的存在，他需要把后面的x=1联通后面的数据一读进core2中；

此时core1 对x=1做了运算是的x=11  
此时core2 对y=2做了运算是的x=22

下你在在core1和core2中的数据如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 2]  
我们发现出现了数据不一致的问题。关于数据不一致问题，这就是伪`共享的问题`。

# 4.缓存对齐可以提高效率 #

知道了cache line的存在，我们在写代码的时候可以利用缓存对齐（就是每次64字节）的方式去提供效率，真的可以吗？  
如果每次不是64个字节，需要等待到了64个字节才会写入缓存哦！中间有等待的时间，是的效率下降。

## 4.1 伪共享时效率低 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 3]

代码如下：

package com.yuhl.c2020.cacheline;
    
    /** * @author yuhl * @Date 2021/1/2 16:04 * @Classname One * @Description cacheline在同一个cup中 效率低 */
    public class One { 
        private static class T { 
            public volatile long x = 0L;
        }
    
        //含有两个Long类型的数据，每个8个字节，大概率会加载到同一个cpu中。
        public static T[] arr = new T[2];
    
        static { 
            arr[0] = new T();
            arr[1] = new T();
        }
    
        public static void main(String[] args) throws Exception { 
            //线程t1修改第一个long 在core1中 由于一致性的存在，需要一个机制做一致性，影响效率
            Thread t1 = new Thread(()->{ 
                for (long i = 0; i < 1000_0000L; i++) { 
                    arr[0].x = i;
                }
            });
    
            //线程t2修改第一个long 在core2中 由于一致性的存在，需要一个机制做一致性，影响效率
            Thread t2 = new Thread(()->{ 
                for (long i = 0; i < 1000_0000L; i++) { 
                    arr[1].x = i;
                }
            });
    
            final long start = System.nanoTime();
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println((System.nanoTime() - start)/100_0000);
        }
    }

## 4.2 缓存对齐时效率高，不存在伪共享 ##

直观看高了3倍

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 4]  
代码如下：

package com.yuhl.c2020.cacheline;
    
    /** * @author yuhl * @Date 2021/1/2 16:05 * @Classname Two * @Description cahcheline不在同一个cup中，效率更高 */
    public class Two { 
        private static class Padding { 
            public volatile long p1, p2, p3, p4, p5, p6, p7;
        }
    
        //继承Padding ,内衣金含有p1, p2, p3, p4, p5, p6, p7 56个字节的数据了，再加上 long x 大概路占用了一个缓存行，
        //线程2 按到T的时候前面也有p1, p2, p3, p4, p5, p6, p7 56个字节的数据了，后面才是long x 所以 一定不存在为共享的问题，也就不存在某机制保证
        //一致性的问题了。效率会高
        private static class T extends Padding { 
            public volatile long x = 0L;
        }
    
        public static T[] arr = new T[2];
    
        static { 
            arr[0] = new T();
            arr[1] = new T();
        }
    
        public static void main(String[] args) throws Exception { 
            Thread t1 = new Thread(()->{ 
                for (long i = 0; i < 1000_0000L; i++) { 
                    arr[0].x = i;
                }
            });
    
            Thread t2 = new Thread(()->{ 
                for (long i = 0; i < 1000_0000L; i++) { 
                    arr[1].x = i;
                }
            });
    
            final long start = System.nanoTime();
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println((System.nanoTime() - start)/100_0000);
        }
    }

# 5.伪共享问题引出数据一致性问题 #

上面提到了伪共享时会造成数据不一致问题，那么为了保证一致性我们应该怎么办么？目前x86架构下有哪些解决方案？

# 6.数据一致性问题解决方案 #

针对一致性的问题有两种解决方案：

1.  总线锁:在L3和L2直接加锁，拿到锁才能处理下面工作。
2.  一致性协议MESI（缓存一致性协议）  
    即通过四个状态来保证数据的一致性：

<table> 
 <thead> 
  <tr> 
   <th>状态</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>modify</td> 
   <td>更改过标注</td> 
  </tr> 
  <tr> 
   <td>exclusive</td> 
   <td>独享</td> 
  </tr> 
  <tr> 
   <td>shared</td> 
   <td>共享</td> 
  </tr> 
  <tr> 
   <td>invalid</td> 
   <td>我读取是被别的core改动过标记，最终需要我再次同步下</td> 
  </tr> 
 </tbody> 
</table>

[关于缓存一致性的详细信息可以参考：https://blog.csdn.net/yahoo1994/article/details/108485859][https_blog.csdn.net_yahoo1994_article_details_108485859]

[下一篇：031-JVM-合并写(write combining) https://yuhongliang.blog.csdn.net/article/details/112135299][031-JVM-_write combining_ https_yuhongliang.blog.csdn.net_article_details_112135299]

[029-JVM-volatil e_ https_yuhongliang.blog.csdn.net_article_details_111997753]: https://yuhongliang.blog.csdn.net/article/details/111997753
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70]: /images/20221120/496759fc248b4538aad7faacc704d5d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 1]: /images/20221120/285d694c0fa845e78ec43ab6ce0750ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 2]: /images/20221120/a2261c3701e64c27a5da57ca75e1b4f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 3]: /images/20221120/95587fffe45542d7ab9b0c18e4f0b310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70 4]: /images/20221120/654d6a978d344bd881395cb5b25f0a91.png
[https_blog.csdn.net_yahoo1994_article_details_108485859]: https://blog.csdn.net/yahoo1994/article/details/108485859
[031-JVM-_write combining_ https_yuhongliang.blog.csdn.net_article_details_112135299]: https://yuhongliang.blog.csdn.net/article/details/112135299