问题 提高读取易失性存储器的性能

没有波动的问题

让我们假设一下 volatile 从数据数组中省略。然后是C编译器 并且CPU不知道它的元素在程序流之外发生了变化。一些 事情 可以 然后发生：

• 整个数组可能会被加载到缓存中 myTask() 被要求 第一次。该数组可能永远保留在缓存中，永远不会 再次从“主”内存更新。这个问题在多核问题上更加紧迫 CPU如果 myTask() 例如，绑定到单个核心。

• 如果 myTask() 内联到父函数，编译器可能会决定 将循环外的负载提升到DMA传输点 尚未完成。

• 编译器甚至可以确定没有发生写入 memoryBuffer 并假设数组元素始终保持为0 （这将再次引发大量优化）。如果这可能发生 程序相当小，编译器可以看到所有代码 立刻（或使用LTO）。 记得：毕竟编译器对DMA没有任何了解 外围并且它正在“意外地和疯狂地写入记忆” （从编译器的角度来看）。

如果编译器是愚蠢/保守的并且CPU不是很复杂（单核，没有无序执行），那么代码甚至可以在没有 volatile 宣言。但它也可能不会......

易变的问题

制造 整个阵列 volatile 往往是一种悲观情绪。出于速度原因你 可能想要展开循环。所以不要从中加载 数组并交替递增索引，如

load memoryBuffer[m]
m += 1;
load memoryBuffer[m]
m += 1;
load memoryBuffer[m]
m += 1;
load memoryBuffer[m]
m += 1;

一次加载多个元素并增加索引可以更快 在更大的步骤，如

load memoryBuffer[m]
load memoryBuffer[m + 1]
load memoryBuffer[m + 2]
load memoryBuffer[m + 3]
m += 4;

如果负载可以融合在一起（例如，执行，则尤其如此） 一个32位负载而不是两个16位负载）。进一步你想要的 编译器使用SIMD指令处理多个数组元素 一条指令。

如果负载发生，通常会阻止这些优化 易失性内存，因为编译器通常非常保守 加载/存储易失性存储器访问的重新排序。 同样，编译器供应商之间的行为也不同（例如，MSVC与GCC）。

可能的解决方案1：围栏

所以你想让数组非易失性但是为编译器/ CPU添加一个提示 “当你看到这一行（执行此语句）时，刷新缓存并从内存重新加载数组”。在C11中你可以插入一个 atomic_thread_fence 在。。。之初 myTask()。这样的围栏阻止了它们之间的装载/存储的重新排序。

由于我们没有C11编译器，因此我们使用内在函数来完成此任务。 ARMCC编译器有一个 __dmb() 内在的（数据记忆障碍）。对于海湾合作委员会，你可能想看看 __sync_synchronize() （DOC）。

可能的解决方案2：原子变量保持缓冲状态

我们在代码库中使用了以下模式（例如，从中读取数据时） SPI通过DMA并调用一个函数来分析它）：缓冲区被声明为 普通阵列（没有 volatile并且每个缓冲区都添加了一个原子标志 在DMA传输完成时设置。代码看起来很像 喜欢这个：

typedef struct Buffer
{
    uint16_t data[10][20];
    // Flag indicating if the buffer has been filled. Only use atomic instructions on it!
    int filled;
    // C11: atomic_int filled;
    // C++: std::atomic_bool filled{false};
} Buffer_t;

Buffer_t buffers[2];

Buffer_t* volatile currentDmaBuffer; // using volatile here because I'm lazy

void setupDMA(void)
{
    for (int i = 0; i < 2; ++i)
    {
        int bufferFilled;
        // Atomically load the flag.
        bufferFilled = __sync_fetch_and_or(&buffers[i].filled, 0);
        // C11: bufferFilled = atomic_load(&buffers[i].filled);
        // C++: bufferFilled = buffers[i].filled;

        if (!bufferFilled)
        {
            currentDmaBuffer = &buffers[i];
            ... configure DMA to write to buffers[i].data and start it
        }
    }

    // If you end up here, there is no free buffer available because the
    // data processing takes too long.
}

void DMA_done_IRQHandler(void)
{
    // ... stop DMA if needed

    // Atomically set the flag indicating that the buffer has been filled.
    __sync_fetch_and_or(&currentDmaBuffer->filled, 1);
    // C11: atomic_store(&currentDmaBuffer->filled, 1);
    // C++: currentDmaBuffer->filled = true;

    currentDmaBuffer = 0;
    // ... possibly start another DMA transfer ...
}

void myTask(Buffer_t* buffer)
{
    for (uint8_t n=0; n<10; n++)
        for (uint8_t m=0; m<20; m++)
            foo(buffer->data[n][m]);

    // Reset the flag atomically.
    __sync_fetch_and_and(&buffer->filled, 0);
    // C11: atomic_store(&buffer->filled, 0);
    // C++: buffer->filled = false;
}

void waitForData(void)
{
    // ... see setupDma(void) ...
}

将缓冲区与原子配对的优点是，您可以检测到处理速度太慢意味着您必须缓冲更多， 使传入的数据更慢或处理代码更快或者更快 在你的情况下足够了。

可能的解决方案3：OS支持

如果您有（嵌入式）操作系统，则可能需要使用其他模式而不是使用易失性数组。我们使用的操作系统具有内存池和队列。后者可以从线程或中断填充，线程可以阻塞 队列，直到它是非空的。该模式看起来有点像这样：

MemoryPool pool;              // A pool to acquire DMA buffers.
Queue bufferQueue;            // A queue for pointers to buffers filled by the DMA.
void* volatile currentBuffer; // The buffer currently filled by the DMA.

void setupDMA(void)
{
    currentBuffer = MemoryPool_Allocate(&pool, 20 * 10 * sizeof(uint16_t));
    // ... make the DMA write to currentBuffer
}

void DMA_done_IRQHandler(void)
{
    // ... stop DMA if needed

    Queue_Post(&bufferQueue, currentBuffer);
    currentBuffer = 0;
}

void myTask(void)
{
    void* buffer = Queue_Wait(&bufferQueue);
    [... work with buffer ...]
    MemoryPool_Deallocate(&pool, buffer);
}

这可能是最简单的实现方法，但前提是您有操作系统 如果可移植性不是问题。