预取技术是如何提升对Flash的AHB读访问效率的？

大家好，我是痞子衡，是正经搞技术的痞子。今天痞子衡给大家介绍的是实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形。

上一篇文章 《实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形（无缓存）》 里痞子衡抓取了Cache和Prefetch全部关闭下的AHB读访问对应的Flash端时序波形图，相信大家对最基本的FlexSPI读访问支持有了感性认识。根据那篇文章我们知道，没有缓存加持的Flash访问，效率是相当低的。应用程序中对同一Flash地址空间的重复访问，FlexSPI底层每次都机械似的再读一次Flash，这就算了，甚至于代码中的大数据块的Flash读访问还会被拆分成多个不高于8byte的小数据块访问时序（每个CS有效期间前20个SCK周期都不是数据序列），这实在是浪费了太多时间（SCK周期）。

针对这种低效情况，FlexSPI模块中集成了预取（Prefetch）技术，今天痞子衡就来继续测一测开启Prefetch功能下的Flash AHB读访问情形（注意本文不涉及内核的L1 Cache技术）：

一、FlexSPI的预取功能

FlexSPI模块内部一共有4个AHB RX Buffer，总大小是1KB（针对i.MXRT1050而言），用户可以自由配置这四个Buffer，这些AHB RX Buffer可以特殊指定给具体AHB master，并且还可以配置各自优先级，具体可以查阅芯片参考手册FlexSPI章节的 AHB RX Buffer Management 小节。

这些AHB RX Buffer就是专门为Prefetch功能准备的，有了AHB RX Buffer，FlexSPI模块就可以在用户程序代码之上做些优化工作。比如代码中发生了Flash访问操作，在一次CS有效周期内FlexSPI直接按相应AHB RX Buffer长度来读取数据缓存下来，而不是按照代码中指定的读取长度，这样可以大大减少因AHB Burst Read策略导致的CS信号拆分情况，而且如果下次同一master要取的数据恰好在AHB RX Buffer里，FlexSPI就不用再重新去Flash里读取数据了。

Prefetch功能说起来就上面那么简单的一段话，但是细细分析这段话，其实还是有如下一些小疑问在里面的，这些疑问痞子衡将用测试结果来给你解答。

• 疑问1：发生预取操作时，AHB RX Buffer是从哪里开始缓存？一定是代码里实际指定的Flash读取操作起始地址吗？疑问2：一旦发生了预取操作，一定是持续到当前AHB RX Buffer满才会中止吗？有没有被打断的可能性？

关于AHB RX Buffer的配置，有很多种不同的策略，痞子衡今天要测的主要是BootROM里启用的一种最简单直接的策略，即AHB RX Buffer 0 - 2全部关掉，仅启用AHB RX Buffer 3，总1KB RX Buffer空间全部给这个AHB RX Buffer 3，所有master均通过AHB RX Buffer 3来访问Flash，且访问优先级一致。

二、Prefetch实验准备

参考文章 《实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形（无缓存）》 里的第一小节 实验准备，本次实验需要做一样的准备工作。

三、Prefetch实验代码

参考文章 《实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形（无缓存）》 里的第二小节 实验代码，本次实验代码关于工程和链接文件方面是一样的设置，但是具体测试函数改成如下ramfunc型函数 test_prefetch_read()。关于Prefetch这次会有很多种不同测试，while(1)语句前的系统配置保持不变，while(1)里面的语句可根据实际测试情况去调整：

#if (defined(__ICCARM__))
#pragma optimize = none
__ramfunc 
#endif
void test_prefetch_read(void)
{
    // 系统配置
    /* Disable L1 I-Cache*/
    SCB_DisableICache();

    /* Disable L1 D-Cache*/
    SCB_DisableDCache();

    /* Enable FlexSPI AHB read prefetch */
    FLEXSPI->AHBCR |= (FLEXSPI_AHBCR_PREFETCHEN_MASK | FLEXSPI_AHBCR_CACHABLEEN_MASK);
    for (uint32_t index = 0; index < FLEXSPI_AHBRXBUFCR0_COUNT; index++)
    {
        FLEXSPI->AHBRXBUFCR0[index] &= ~(FLEXSPI_AHBRXBUFCR0_BUFSZ_MASK | FLEXSPI_AHBRXBUFCR0_MSTRID_MASK | FLEXSPI_AHBRXBUFCR0_PRIORITY_MASK);
    }

    while (1)
    {
        // 测试用例代码，可按情况调整
    } 
}

四、Prefetch实验结果

4.1 循环读取同一数据块（1KB以内）

本系列测试用例沿用上一篇文章中特殊const数据区.ahbRdBuffer设置，0x60002400 - 0x600027ff 空间的前16字节是指定的，后面区域就由IDE自由链接应用程序代码数据，我们暂不需要在IO[1:0]信号上具体观察这个区域的数据：

const uint8_t ahbRdBlock[16] @ ".ahbRdBuffer" = {
    0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
    0x20, 0x21, 0x22, 0x23, 0x30, 0x31, 0x32, 0x33,
};
// 在工程链接文件中
keep{ section .ahbRdBuffer };
place at address mem:0x60002400 { readonly section .ahbRdBuffer };

4.1.1 访问首地址按八字节对齐

先来看最典型的测试，从八字节对齐地址 PREFETCH_TEST_START 处读取 testLen 长度的数据，该函数里第一次memcpy语句的执行便会触发Prefetch机制，当 testLen 不大于 PREFETCH_TEST_MAX_LEN（1KB） 时，Flash端时序波形图都是同一个，即仅产生一次CS低有效周期（后续循环执行均从AHB RX Buffer直接取数据了），低有效持续时间约为65.2us，按SCK周期31.6ns来算，一共有2068个SCK周期，减去读时序里固定前20个命令地址周期，剩2048个数据SCK周期（一个SCK周期传输4bit数据），即读取1KB数据：

#define PREFETCH_TEST_ALIGNMENT  (0) // 可取值 8*n
#define PREFETCH_TEST_START      (0x60002400 + PREFETCH_TEST_ALIGNMENT)
#define PREFETCH_TEST_MAX_LEN    (0x400)
uint32_t testLen = 0x1;  // 可取值 1 - 0x400
void test_prefetch_read(void)
{
    // 略去系统配置
    testLen = (testLen > PREFETCH_TEST_MAX_LEN) ? PREFETCH_TEST_MAX_LEN : testLen;
    while (1)
    {
        memcpy((void *)0x20200000, (void *)PREFETCH_TEST_START, testLen);
    } 
}

4.1.2 访问首地址非八字节对齐，长度小于1KB - 对齐字节

第二个测试是 PREFETCH_TEST_START 地址并非八字节对齐，这种情况下如果 testLen 不大于1KB - PREFETCH_TEST_ALIGNMENT，那么Flash端时序波形图还是同一个，并且跟上一种测试情况结果是一样的，均是读取1KB数据。放大初始时序图来看，代码中实际Flash读取起始地址是0x60002407，但是FlexSPI的Prefetch机制会将其按八字节向前对齐到0x60002400来读取（实际传输时序里是0x002400三字节地址，输出数据是0x00、0x01、0x02...），这也意味着AHB RX Buffer存储的数据永远是从八字节地址对齐处开始的（回答了第一节里的疑问1）。

#define PREFETCH_TEST_ALIGNMENT  (7) // 可取值 1 - 7
#define PREFETCH_TEST_START      (0x60002400 + PREFETCH_TEST_ALIGNMENT)
#define PREFETCH_TEST_MAX_LEN    (0x400 - PREFETCH_TEST_ALIGNMENT)
uint32_t testLen = 0x1;  // 可取值 1 - PREFETCH_TEST_MAX_LEN
void test_prefetch_read(void)
{
    // 略去系统配置
    testLen = (testLen > PREFETCH_TEST_MAX_LEN) ? PREFETCH_TEST_MAX_LEN : testLen;
    while (1)
    {
        memcpy((void *)0x20200000, (void *)PREFETCH_TEST_START, testLen);
    } 
}

4.2 循环读取同一数据块（大于1KB）

为了便于分辨IO[1:0]上的数据去帮助分析本系列测试用例结果，此处我们需要拓展下特殊const数据区.ahbRdBuffer设置如下：

const uint8_t ahbRdBlock1[1024] @ ".ahbRdBuffer1" = {
    // 正顺序
    0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
    0x20, 0x21, 0x22, 0x23, 0x30, 0x31, 0x32, 0x33,
    // 倒顺序
    0x33, 0x32, 0x31, 0x30, 0x23, 0x22, 0x21, 0x20,
    0x13, 0x12, 0x11, 0x10, 0x03, 0x02, 0x01, 0x00,
};
const uint8_t ahbRdBlock2[1024] @ ".ahbRdBuffer2" = {
    // 正插序
    0x01, 0x00, 0x03, 0x02, 0x11, 0x10, 0x13, 0x12, 
    0x21, 0x20, 0x23, 0x22, 0x31, 0x30, 0x33, 0x32, 
    // 倒插序
    0x32, 0x33, 0x30, 0x31, 0x22, 0x23, 0x20, 0x21, 
    0x12, 0x13, 0x10, 0x11, 0x02, 0x03, 0x00, 0x01, 
};
// 在工程链接文件中
keep{ section .ahbRdBuffer1, section .ahbRdBuffer2 };
place at address mem:0x60002400 { readonly section .ahbRdBuffer1 };
place at address mem:0x60002800 { readonly section .ahbRdBuffer2 };

4.2.1 访问首地址按八字节对齐

第三个测试是从八字节对齐地址 PREFETCH_TEST_START 处读取 testLen 长度的数据，testLen大于1KB，这种情况下我们在Flash端看到了周期性的波形图，这说明1KB的AHB RX Buffer不足以缓存此时代码里的数据访问需求，因此AHB RX Buffer被不断地清除和重新缓存。放大时序图来看，一个完整周期内，第一个CS有效期间读取了0x60002400开始的1KB数据，第二个CS有效期间读取了0x60002800开始的15个字节数据（总有效时间1.55us），痞子衡知道你肯定觉得奇怪，测试testLen设的是0x401，为何第二个CS期间Prefetch机制缓存的是15个字节？既不是1KB，也不是1byte。这其实是因为第二次CS有效期间的Prefetch操作被下一次while(1)回来的数据访问需求打断了，所以这意味着一旦Prefetch操作被使能，Prefetch机制会尝试缓存到填满AHB RX Buffer，但如果在Buffer满之前有全新的数据访问需求发生，当前Prefetch操作会被中止，Buffer清空，重新开始下一次Prefetch操作（这里回答了第一节里的疑问2）。

#define PREFETCH_TEST_ALIGNMENT  (0) // 可取值 8*n
#define PREFETCH_TEST_START      (0x60002400 + PREFETCH_TEST_ALIGNMENT)
#define PREFETCH_TEST_MIN_LEN    (0x400)
uint32_t testLen = 0x401;  // 可取值 0x401 - 0x800
void test_prefetch_read(void)
{
    // 略去系统配置
    testLen = (testLen <= PREFETCH_TEST_MIN_LEN) ? (PREFETCH_TEST_MIN_LEN + testLen) : testLen;
    while (1)
    {
        memcpy((void *)0x20200000, (void *)PREFETCH_TEST_START, testLen);
    } 
}

基于上面的分析，我们追加一个实验，在memcpy语句后面加一点软延时，保证第二次CS有效期间Prefetch操作有足够的时间去将AHB RX Buffer填满，我们知道1KB的Flash数据读取约耗时65.2us，我们就延时70us以上试试看，果然这次看到第二个CS也同样持续了65.2us。

void test_prefetch_read(void)
{
    // 略去系统配置
    while (1)
    {
        memcpy((void *)0x20200000, (void *)0x60002400, 0x401);
        SDK_DelayAtLeastUs(70, SystemCoreClock);
    } 
}

4.2.2 访问首地址非八字节对齐

第四个测试是从非八字节对齐地址处读取超过 1KB 长度的数据，结合4.1节的测试结果，我们可以将代码中的实际语句 memcpy((void *)0x20200001, (void *)0x60002401, 0x401); 做等效转换为 memcpy((void *)0x20200000, (void *)0x60002400, 0x402);，这里就不多贴结果图了。

void test_prefetch_read(void)
{
    // 略去系统配置
    while (1)
    {
        memcpy((void *)0x20200001, (void *)0x60002401, 0x401);
        // 从Flash端信号传输来看，几乎等效于如下语句
        //memcpy((void *)0x20200000, (void *)0x60002400, 0x402);
    } 
}

4.3 循环读取两个不同数据块（1KB以内）

最后一个实验是循环读取两个不连续数据块，有了前面的测试结果，这个测试的结果也在意料之中了，每个CS持续时间约17us（大约537个SCK周期），实际传输略多于256个byte的数据，这也是符合Prefetch操作会被中止的分析的。如果想看到完整的1KB缓存，memcpy后需要插入至少48.2us以上的软延时。

void test_prefetch_read(void)
{
    // 略去系统配置
    while (1)
    {
        memcpy((void *)0x20200000, (void *)0x60002400, 0x100);
        memcpy((void *)0x20200400, (void *)0x60002800, 0x100);
    } 
}

至此，实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形痞子衡便介绍完毕了，掌声在哪里~~~