031-JVM-合并写(write combining)

怼烎@ 2023-01-01 14:50 113阅读 0赞

[上一篇：030-JVM-Cache Line、缓存对齐、伪共享https://yuhongliang.blog.csdn.net/article/details/112099904][030-JVM-Cache Line_https_yuhongliang.blog.csdn.net_article_details_112099904]  
当cpu修改了某值后会把数据线存入L1中，这个时候可能没有命中，则会一往下查找，会写入到L2中，此时，由于往L2中写的时候需要大量的时间，同时这个变量还可能继续被修改，此时会用到合并写的技术，所谓合并写就是把两次的写的结果一次进行写出。  
这里会用到合并鞋的地址空间，一共4个字节，也就是如果我们的修改在4个字节以内，则会使用到合并写的技术，如果超过4个字节，则无法使用到合写的红利。

下面给出一个例子，

# 1. 一次写6个字节 #

package com.yuhl.c2020;
    
    /** * @author yuhl * @Date 2021/1/3 15:20 * @Classname WriteCombining * @Description 合并写 */
    public class WriteCombining { 
    
        private static final int ITERATIONS = Integer.MAX_VALUE;
        private static final int ITEMS = 1 << 24;
        private static final int MASK = ITEMS - 1;
    
        private static final byte[] arrayA = new byte[ITEMS];
        private static final byte[] arrayB = new byte[ITEMS];
        private static final byte[] arrayC = new byte[ITEMS];
        private static final byte[] arrayD = new byte[ITEMS];
        private static final byte[] arrayE = new byte[ITEMS];
        private static final byte[] arrayF = new byte[ITEMS];
    
        public static void main(final String[] args) { 
    
            for (int i = 1; i <= 3; i++) { 
                System.out.println(i + " SingleLoop duration (ns) = " + runCaseOne());
                System.out.println(i + " SplitLoop duration (ns) = " + runCaseTwo());
            }
        }
    
        public static long runCaseOne() { 
            long start = System.nanoTime();
            int i = ITERATIONS;
    
            while (--i != 0) { 
                int slot = i & MASK;
                byte b = (byte) i;
                arrayA[slot] = b;
                arrayB[slot] = b;
                arrayC[slot] = b;
                arrayD[slot] = b;
                arrayE[slot] = b;
                arrayF[slot] = b;
            }
            return System.nanoTime() - start;
        }
    
        public static long runCaseTwo() { 
            long start = System.nanoTime();
            int i = ITERATIONS;
            while (--i != 0) { 
                int slot = i & MASK;
                byte b = (byte) i;
                arrayA[slot] = b;
                arrayB[slot] = b;
                arrayC[slot] = b;
            }
            i = ITERATIONS;
            while (--i != 0) { 
                int slot = i & MASK;
                byte b = (byte) i;
                arrayD[slot] = b;
                arrayE[slot] = b;
                arrayF[slot] = b;
            }
            return System.nanoTime() - start;
        }
    }

结论：

1 SingleLoop duration (ns) = 8619677900
    1 SplitLoop  duration (ns) = 7768035100

# 2. 一次写3个字节，分两次，也是6个字节 #

SplitLoop 效率更高。

# 3. 总结 #

上面的例子结论说明一次写3个字节，分两次，也是6个字节更快，使用了合并写的技术支持，而一次写6个字节则需要每次进行L2写入，降低的效率。

[下一篇：032-JVM-指令重排验证https://yuhongliang.blog.csdn.net/article/details/112135527][032-JVM-_https_yuhongliang.blog.csdn.net_article_details_112135527]

[030-JVM-Cache Line_https_yuhongliang.blog.csdn.net_article_details_112099904]: https://yuhongliang.blog.csdn.net/article/details/112099904
[032-JVM-_https_yuhongliang.blog.csdn.net_article_details_112135527]: https://yuhongliang.blog.csdn.net/article/details/112135527