javascript - NodeJS 中是否可能发生缓存未命中以及如何获取它？

Question

来自 Wikipedia ，缓存未命中是在缓存中读取或写入一段数据的失败尝试，这会导致主内存访问具有更长的延迟。

但是，我不明白我们在谈论什么样的数据以及如何综合再现这些数据。基于this答案，缓存优化是通过调整算法来避免访问时出现数据碎片。

/* Array.prototype.flat polyfill */
Array.prototype.flat = function() {
    this.reduce((a, v) => Array.isArray(v) ? a.concat(v.flat()) : a.concat(v), []);
};
/* Cache test */
const len = 100;
const generateArr = (len) =>  {
    const mat = [...new Array(len)].map(() => 
        [...new Array(len)].map(() => Math.round(Math.random() * 10))
    );
    return new Uint8Array(mat.flat(Infinity))
};
const arr = generateArr(len)
/* {1, 2, 3, 4, 5, 6, 7, 8, 9, n} */
const testFriendly = () => {
    let total=0;    
    for (let x=0;x!=len;x+=10) {
        for (let y=0;y!=10;y++) {
            total+=arr[x+y];
        }
    }
};
/* {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 1, 11, 12, n}*/
const testUnfriendly = () => {
    let total=0;
    for (let y=0;y!=10;y++) {
        for (let x=0;x!=len;x+=10) {
            total+=arr[x+y];
        }
    }
};
const test = () => {
    console.time("Cache-friendly");
    for (let i=0; i!=7000; i++) {
        testFriendly();
    }
    console.timeEnd("Cache-friendly");
    console.time("Cache-unfriendly");
    for (let i=0; i!=7000; i++) {
        testUnfriendly();
    }
    console.timeEnd("Cache-unfriendly");
};
test()
test()
test()
test()

JIT 完成后，友好测试运行得更快，但并非总是如此。这是缓存未命中吗？

但是应用程序程序员可以在 NodeJS 平台上获得缓存未命中吗？是否有任何反模式来保证缓存未命中并防止生产代码中出现类似情况？

Answer 1

what kind of data we are talking about?

基本上所有数据。

可以存储(写入、读取)数据的三个地方:

(1) 直接在处理器上注册[几个字节]。

(2) RAM(前面有缓存)[几 GB/TB]

(3) I/O(硬盘、SSD、网络适配器)[无限制]

因为您不能直接访问 (1) 和 (3)，所以您的所有数据基本上都在 RAM 中结束。

Is cache miss possible in NodeJS and how to get it?

当然。在最佳情况下，如果你使用的所有数据都被缓存，并且整个缓存都被利用，几 kB 存储在 L1 中，几百 kB 存储在 L2 中，几 MB 存储在 L3 中。因此，如果您处理的数据超过这些缓存所能容纳的数据量，缓存未命中肯定会发生(尽管如此，它们很可能会发生)。

After the JIT completes, the friendly test runs faster, but not always. Is this a cache miss?

好吧，让我们看一下您正在操作的堆栈:

JavaScript <- you are here
/* gets run by */
V8 / NodeJS <- optimizations do happen
/* is written in */
C++ <- optimizations do happen, the other question is at this level
/* gets compiled to */
bytecode <- optimizations do happen
/* gets finally run on */
The Processor <- here the caches come into play

换句话说:与 C++ 问题不同，在 NodeJS 中还有另一个优化级别。该级别可能会引入其他缓存，可能会改变数据在内存中的表示方式，或者进行其他优化。您可以分析 V8 执行的字节码，并为此进行优化......但下一个 V8 版本可能会引入另一种优化，这会使您的“优化”过时。

But can an application programmer get a cache miss on the NodeJS platform?

当然。在引擎盖下的某个地方，很可能，非常频繁。但是……你能做点什么吗？不，不是真的。 V8 团队或 C++ 编译器实现者可以，你不能，真的。

Are there any anti-patterns in order to guarantee a cache miss and prevent similar in production code?

是的，不要写疯狂的代码。

_{估计来自Nick Craver's blog ，我强烈建议阅读:)}